# Isis Chroma on RunPod Serverless — MVP TODOS (2026-09-11)

Last updated: 2026-09-14. Owner: @GreyChimp. Tracker rules:
`.claude/rules/task-checkbox-verification.md` (one task, one verification, one
mark; `[ ]`/`[x]` is the only truth; never batch-mark).

## Objective

Make Isis generate real images end to end on RunPod serverless with the
full-precision Chroma stack (Chroma1-HD, UnCanny Photorealism Chroma v1.3 BF16,
Photonic Fusion Chroma Debloated BF16) plus SAM 3, the three BiRefNet variants
and RMBG-2.0, driven from the existing Isis dashboard (`apps/isis/web`) through
the existing generation API (`apps/isis/generation-api`), with spend bounded by
hard, tested controls. No detour app. Every model lives on a RunPod network
volume and is loaded on demand; nothing is baked into the worker image.

The MVP is done when a person can open the Isis web dashboard, pick a Chroma
workflow, submit a prompt, watch the job run, see the PNG in Outputs, and read
the real dollar cost of that job — and when every one of the workflows below has
produced one real image whose cost was recorded from RunPod's own
`executionTime`/`delayTime` numbers.

**Video extension (added 2026-09-11):** the same stack grows to video — Wan2.2
T2V/I2V/Animate A14B, Wan2.1 VACE 14B, SAM 3 video tracking, BiRefNet
HR-matting, GIMM-VFI, FlashVSR v1.1 and LTX-2.3 22B audio+video — on a second,
equally bounded endpoint, with rich per-workflow controls. Sections V.00–V.12 at
the end of this file; C.xx items are unchanged.

**Arsenal expansion (added 2026-09-13):** every model and LoRA from the
2026-09-13 survey tables joins the scope — LTX-2.5, Wan2.2-Animate-2 (base and
distilled), SeedVR2 3B/7B, SAM 3.1 core, Z-Image base with Alibaba's Fun
ControlNet unions, HiDream-O1-Image Dev, FLUX.2 klein 4B, Qwen-Image-2512 with
Edit-2511 and the InstantX controlnets, SCAIL-2, Depth Anything 3, three Civitai
checkpoints and twenty-one Civitai LoRA files — with the retirements (LTX-2.3,
Animate-1, Depth-Anything-V2-Large, RMBG-2.0) and the content-policy routing
they force. Sections A.00–A.05 at the very end of this file; the volume grows to
1024 GB for them (A.00.01).

**Model library and cache (option B, decided 2026-09-13):** the weights move to
a Hetzner Object Storage library (`app-dev-server` / `isis/models/`, the source
of truth) and the RunPod side becomes a fixed **400 GB cache volume** holding a
pinned core plus whatever else was used most recently, evicted
least-recently-used first and only when an incoming family does not fit. The
1024 GB volume is transitional and is deleted once the library is verified and
the cache is proven. Sections L.00–L.07 at the very end of this file.

**Open 3D studio extension (added 2026-09-13):** sections T.00–T.21 below extend
this same Isis product with specialist mesh generation, procedural/CAD and
reconstruction lanes, editable scenes, PBR, topology, rigging, animation,
bounded director/critic orchestration, printing and engine delivery. The target
is measured Meshy/Higgsfield capability parity using open components. Houdini is
excluded; Astra is an optional hosted controller, not a required generator. The
reviewed architecture, component caveats, dependency order and acceptance tasks
are in
[Open 3D studio architecture and review](#open-3d-studio-architecture-and-review-added-2026-09-13).
These are new implementation tasks, all initially unchecked; the existing
C/V/A/L implementation evidence and checkbox states are preserved.

**Agent tool integration follow-up (2026-09-13):** T.19–T.21 add the official
Unity CLI/Pipeline and its MCP transport, official Blender Lab MCP for live
sessions, and Blender Python/headless workers for repeatable production. The
[agent tool review](#unity-and-blender-agent-tool-review-2026-09-13) compares
alternatives, records version/deprecation caveats and defines the evidence
needed to select the most effective route for each operation.

**Toolbox extension (added 2026-09-14):** sections E.00–E.08 at the very end of
this file take the arsenal past people and poses to sets, wardrobe, dance, music
video, camera control, prompt assistance and a stylised/anime lane, plus a
benchmark that decides per lane whether Isis self-hosts or calls an API, and an
evaluation of the body LoRAs already in the library. The scope comes from the
2026-09-14 toolbox audit (`docs/agents/isis-toolbox-audit-2026-09-14.md`) and
was approved item by item; every model it adds is licence-clean for production
use. The decisions, facts and footprint are in the 2026-09-14 blocks below.

**Hosted image and video lane (added 2026-09-15):** sections H.00–H.07 at the
very end of this file add OpenRouter's image and video models as a hosted lane
beside RunPod, the same way T.22 adds Meshy for 3D. A job or a chain step names
its lane (RunPod, OpenRouter or Meshy), so a person can use the hosted models
and run on RunPod only when they choose to or the job needs it (adult content,
LoRAs, control maps, masks or a custom graph). Owner request, 2026-09-15:
"openrouter has a number of image and video models can we do the same as we are
doing with meshy so we can either choose to use meshy and openrouter in the
comfy workflows or something like this and only use runpod stuff when we want /
need to".

**Film studio in Blender (added 2026-09-18):** sections F.00–F.20 at the very
end of this file build a film production on top of the T-track: screenplay,
breakdown and shot list, storyboards and animatic, previs and layout,
cinematography, sets, casting, body and facial performance, lighting,
simulation, rendering with passes and a colour pipeline, compositing, a
generative finish driven by Blender control passes, editorial on OpenTimelineIO,
sound, grading, delivery and QC, all driven through a provider-independent agent
layer. The trigger was GPT-6 Astra (released 2026-09-03), which public reports
show operating Blender well; it is an opt-in controller profile, measured
against cheaper models before anything routes to it, and never a dependency.
**Owner decision, 2026-09-18: Astra is reached only through the Codex CLI on the
ChatGPT subscription (`codex exec`), never through the OpenAI API, OpenRouter or
any other metered billing.** The 2026-09-18 facts, decisions, coverage map and
cost model are in
[Film studio in Blender](#film-studio-in-blender-f00f20--agentic-film-making-across-every-department-added-2026-09-18).
All 130 F items are new and unchecked.

## State on 2026-09-16

**308/456 checked** (recounted after T.13.06): C 99/101, V 73/75, L 27/28, A
31/36, T 61/160, E 4/41, H 13/15. The hosted OpenRouter lane (H) shipped and ran
live on 2026-09-16 (0.043 USD, two image jobs); **H.00.01 closed later the same
day** — vendor terms now carry a text-normalized sha256, a United Kingdom
verdict and a trains-on-inputs verdict as fields a spec checks, and
`openrouter-terms-drift.ts` re-checks them offline and live. **E.01.01 closed**
the same day: the benchmark suite exists with a spec that validates every entry
against the real catalog. **H.04.01 lost one of its two blockers** — a RunPod
job now records its own submit-time content judgement, so a hosted step no
longer depends on the caller declaring a rating for material it did not make.

What the remaining open items are waiting on, by kind:

- **A vendor's terms nobody can read:** no OpenRouter video model is offered, so
  H.04.01's video direction and H.06.02's video half cannot exist (H.00.01's
  register says which vendors were tried and why each failed).
- **A live worker shell:** H.06.02's other blocker, the `volume/<path>` input
  channel that does not resolve on the live workers.
- **Spend, and an owner decision:** most open A and E items need a live render
  (A.00.05, A.02.02, A.05.02, and everything downstream of E.00.01's proof
  policy); E.00.02 needs a Hetzner library re-read before any pull.
- **A precondition outside this repository:** C.12.05, C.12.06, V.12.05,
  V.12.06, E.01.07 (footage and consents that do not exist yet), L.07.01 (four
  weeks of real use).
- **Unbuilt by design:** the T track (3D) is 34/159 and is a separate build, not
  a set of blocked items. T.03 is complete (T.03.06 closed the sandbox and the
  output registry's forged signed URLs); T.04.01's artifact manifest is built
  for every delivered GLB and T.04.02's registry revisions restore and branch
  accepted assets; T.04.07 (the job→registry producer) waits on an owner
  decision about acting for a tenant's owner.

## Earlier state on 2026-09-14 evening

**236/424 checked** across the file: C 99/101, V 73/75, L 27/28, A 29/36, T
8/143, E 0/41. The A-section retirements are executed: LTX-2.3, Animate-1,
Real-ESRGAN, the SAM 3 packs and rows, Depth Anything V2 and RMBG-2.0 are gone
from the catalog, the manifest, the Hetzner library and the cache (evidence
A.05.03). The manifest holds 98 rows (700.39 GB, 27 families, 9 pinned, pinned
closure 239.03 GB); the library 100 objects (687.82 GB); the cache 136 objects
(331.22 GB, the pinned core plus LTX-2.5). Proof spend at ledger rates: 3.77 USD
(first approval), 6.21 USD (the remainder), then 1.21 USD for the default
LTX-2.5 job, the operator API clip and one post-rebuild still. Open A items and
what each needs: A.00.05 and A.05.02 close with CyberRealistic; A.01.02 an
LTX-2.5 duration-predictor row and a multishot ComfyUI surface; A.02.02 a VRAM
measurement at 1024 and 2048 square; A.03.02 CyberRealistic out of early access;
A.03.04 a clip showing what an explicit Wan pair adds, or an owner decision to
keep or drop them (reopened after diagnosis); A.03.05 conditional on an explicit
ask.

## Earlier state on 2026-09-13 (historical snapshot; read item evidence for later work)

The following counts and blocker notes predate later implementation recorded on
individual items and the T track. They are not a current whole-file status or a
claim that the new T tasks are blocked.

**169/240 checked** (167/176 before the arsenal expansion sections A.00–A.05
were added later on 2026-09-13; V.11.02 and V.11.05 closed that morning with the
approved $1.60 of re-runs; every matrix workflow has rendered). Every unchecked
item carries a dated note on the item itself naming the one thing that unblocks
it; none is actionable without that thing:

- **Spend:** nothing is waiting on money any more. V.11 closed at roughly
  $2.5–3.3 all in (the 2026-09-13 re-runs cost $0.78 plus about $0.10, settled
  balance).
- **A product or space decision:** C.12.01 (which Chroma LoRA), V.12.02 (which
  control set for `ltx23-av`), V.12.03 (46 GB of the 141.6 GB headroom for the
  distilled checkpoint).
- **A precondition outside this initiative:** C.12.05 (a shared CI and
  deploy-workflow change), C.12.14 (a media-rights consent registry), and
  C.12.06 / V.12.05 / V.12.06 (a worker-side S3 uploader, then S3 credentials in
  the endpoint env — typed by a person, never by an agent — then one live
  render).
- **Conditional by their own wording:** V.01.08 (only on a measured >20 s
  cold-start regression), V.11.06 (only if asked), V.12.01 (monthly re-check,
  next about 2026-10-13).
- **Arsenal expansion (A.00–A.05, 36 new items on 2026-09-13):** every survey
  model and LoRA is now scoped with its bytes, licence, pull path and proof; all
  unchecked. A.00.01 (the 1024 GB grow) is executed in this session; every pull
  waits on A.00.02 (the balance top-up, a person's action); the retirements wait
  on their replacements' live renders.
- **Model library and cache (L.00–L.07, 28 new items on 2026-09-13):** option B
  at 400 GB, all unchecked. The first live step is L.00.01's transfer probe
  (about $0.02, asks first); the 1024 GB volume survives until L.06.05.

## Decisions taken by the user on 2026-09-13 (the remaining items, all chosen)

Asked and answered in one sitting; each is binding and each names its spend.

- **C.12.06 / V.12.05 / V.12.06 — outputs go to Hetzner Object Storage, not the
  volume.** Endpoint `hel1.your-objectstorage.com`, existing bucket
  `app-dev-server`, prefix `isis/outputs/<jobId>/`. A bucket-aware uploader
  ships in the worker image (the stock `rp_upload.upload_image` names its bucket
  after the month); the two secret env values are pasted into both endpoints by
  the agent in the console (user's explicit choice), with `COMFY_LOG_LEVEL=INFO`
  and the `COMFY_POLLING_*` values from `desired-state.json` set in the same
  visit. One live render (~$0.10) proves the leg.
- **C.12.01 — four Chroma LoRAs ship**, all from CivitAI with every commercial
  flag (sell images, generation services, sell the model): Lenovo UltraReal
  (model 1662740, version 2299345, trigger `l3n0v0`), Chroma Realistic Slider
  (1995853 / 2259125), Chroma Defluxer (2204954 / 2482626), Style > Muk (1944975
  / 2715471). One live still per LoRA.
- **V.12.03 — the distilled LoRA, not the checkpoint:**
  `ltx-2.3-22b-distilled-lora-384-1.1.safetensors` (7.61 GB) on the dev
  checkpoint as a `speed_mode` (8 steps, CFG 1), to the volume over S3 for $0.
  One live clip.
- **V.12.02 — Union Control and Motion-Track Control IC-LoRAs** (0.65 GB + 0.33
  GB; the "camera LoRAs" exist only for LTX-2 19B and cannot apply to the 22B
  2.3). Needs Lightricks' ComfyUI-LTXVideo pack in the image at a pinned SHA.
  One live clip each for canny, depth, pose and motion-track.
- **V.11.06 — not doing it; closed by decision.** **C.12.14 — closed as
  scoped.** **C.12.05 — parked** (shared CI change). **V.01.08 / D-V2 — measure
  the image endpoint's cold start** with a model-free probe (~$0.01).
- **Ledger rate:** `ISIS_COST_RATE_RUNPOD_VIDEO_USD_PER_SECOND` becomes
  **0.001647** (H200, the dearest card actually in the EU endpoint's list), per
  the written "dearest card" rule; 0.0024 was the deleted US endpoint's B200.
- **Proof policy for the new capabilities: one live render per LoRA and per
  mode** (about $0.80 all in) on top of the offline validators, each flipping
  its entry to `rendered`.

## Decisions taken by the user on 2026-09-13 (arsenal expansion, later the same day)

- **Everything in the survey tables is in scope** ("add all these models across
  all the tables"), including the rows the survey had marked optional or
  conditional: HiDream-O1-Image Dev, FLUX.2 klein 4B, Qwen-Image-2512 with
  Edit-2511, SCAIL-2 and the Animate-2 distilled checkpoint. Nothing is deferred
  for space; the volume grows instead ("expand the storage volume as needed to
  accommodate them all"). The size is derived, not chosen: the peak footprint
  with every row present and nothing yet retired is 798.4 GB, and the lint's 20
  % floor puts that at 1024 GB (A.00.01; the arsenal footprint table has the
  arithmetic).
- **Content policy.** Racy and artistic-nude work (music-video and
  Bayonetta-grade, tasteful film nudity — the user's words) is generated on
  Chroma, Z-Image, Wan 2.2, Animate-2 and SCAIL-2: Apache-2.0 or MIT, no
  acceptable-use policy, and the bases render anatomy natively. LTX-2.5,
  HiDream-O1, klein 4B and Qwen-Image are **SFW-only**: the LTX-2.x community
  licence incorporates Lightricks' acceptable-use policy (no "sexual intercourse
  or sex acts", no "sexual fetishes or fantasies", and in its API section no
  "sexually explicit or suggestive content"); HiDream-O1's base blurs skin;
  klein's stock Qwen3 encoder blocks adult prompts and the only abliterated
  encoder is non-commercial; Qwen-Image is weak at nudity by design. Explicit
  sex-act LoRAs, which dominate Civitai's download charts, are out of scope; the
  tier taken is realism, anatomy, body-shape sliders, dance and camera.
- **Civitai flag rule.** A row a tenant can reach needs both `Image` (sell the
  generated media) and `Rent` (use on a generation service). Rows carrying
  `Image` without `Rent` — NSFW Posing Nude, Bouncing Boobs, Twerking, Slow
  Twerk — are pulled but tagged `internal_only`: fine for Isis rendering Oshun's
  own media, never listed to Lilith users (A.04.02).
- **Photonic Fusion Chroma is `internal_only` too**, by the same rule: its
  Civitai grant is `Image` and `RentCivit` only (no `Rent`, no `Sell`), verified
  2026-09-13 through the model API. UnCanny, Chroma1-HD and UnGloryHail carry
  all four flags (A.04.03).
- **Removed from the candidate list:** Krea 2 and Kroma (community licence §4.2
  requires deployed content filters and names NudeNet as an example, plus a $1M
  revenue and 50-seat cap). **Still excluded:** MiniMax H3 and every Tencent
  Hunyuan model (licence territory excludes the EU and the UK), Anima
  (CircleStone non-commercial licence), Sulphur-2 (no licence, int8-only ports),
  Ideogram 4 open weights (fp8-only and gated, fails D-V5), and the `ponpoke`
  abliterated klein encoder (flux-non-commercial). A future session must not
  re-add these (A.04.04 keeps the register).
- **Proof policy unchanged:** one live render per new model and per LoRA, on top
  of the offline validators; each flips its entry to `rendered`.

## Decision taken by the user on 2026-09-13 (model library on Hetzner, 400 GB LRU cache on RunPod)

- **Why:** generation happens only at certain hours, but a RunPod network volume
  bills every hour whether or not a worker touches it. At 1024 GB that is
  $71.20/month, while the whole V.11 proof matrix cost about $3 of GPU — storage
  had become ten to twenty times the compute spend. Hetzner's base price,
  already paid, includes 1 TB of storage and 1 TB of egress per **account**,
  ingress is free, and extra egress is €1.00/TB; RunPod charges nothing for data
  in. The whole library therefore costs about €0 extra on Hetzner, and a cache
  miss costs waiting time, not money.
- **Options weighed:** (A) keep the 1024 GB volume, $71.20; (B) Hetzner library
  plus a fixed cache volume, chosen; (C) create and destroy a volume per session
  — rejected: the endpoints would need re-pointing every session, a path that
  has wedged an endpoint before, and every session pays a pull; (D) no volume,
  pull into each worker's disk — rejected: every cold worker re-pulls while
  GPU-billed.
- **Size: 400 GB ($28.00/month).** The pinned core is 212.26 GB (below), which
  leaves 188 GB for rotating families: any two of them fit (for example
  Qwen-Image plus Animate-2, or LTX-2.5 plus Animate-2); Qwen-Image and LTX-2.5
  on the same day (188.23 GB) is the one pairing that needs 450. 200 GB was
  rejected because it cannot hold the core; 300 GB cannot load Qwen-Image at all
  beside the core. Volumes only grow, so start at 400 and grow on the evidence
  of the miss log (L.07.01), never on a guess.
- **Pinned core (sums of the manifest's family totals, 2026-09-13):** Chroma
  stack with the four C.12.01 LoRAs 63.74 GB; Wan 2.2 I2V experts plus 4-step
  LoRAs 59.61; Wan 2.2 T2V experts plus 4-step LoRAs 59.61; Wan shared (umt5,
  VAE, clip vision) 12.88; SAM 3 6.90; BiRefNet 2.21; FlashVSR 6.95; GIMM-VFI
  0.29; RealESRGAN 0.07 — **212.26 GB**. The other 154.91 GB on the volume today
  (LTX-2.3 80.37, Animate-1 35.99, VACE 34.68, controlnet_aux 1.69, Animate-1
  preprocess 1.30, RMBG-2.0 0.88) is unpinned from day one.
- **Eviction rules (the user's design, confirmed in conversation):** the core is
  never evicted; everything else stays until space is needed for another family;
  when space is needed, the family whose last use is **longest ago** is evicted
  first. Four safety rules make that correct: the unit of eviction is a
  **family**, and shared files are reference-counted (a file leaves only when no
  remaining cached or pinned family needs it — umt5 serves Wan, Animate-2 and
  SCAIL-2; `ae.safetensors` serves Chroma and Z-Image; `qwen_3_4b` serves
  Z-Image and klein 4B); a family a queued or running job needs is **leased**
  and never evicted (deleting weights under a live ComfyUI crashes it, and a
  crashed worker poisons every job after it); eviction happens **only** when the
  incoming bytes plus a margin do not fit, and if they cannot fit even with
  every unpinned family gone the sync fails before any byte moves; "last used"
  comes from the job ledger when a job completes, never from filesystem access
  times. Every hit, miss and eviction is logged.
- **Consequences for the A sections:** the arsenal pulls land in the library,
  not on a volume (A.00.03 and A.00.04 carry dated notes); A.00.01's 1024 GB
  size becomes transitional; A.00.06's tier-aware panel line is moot at 400 GB
  (flat $0.07 is exact below 1 TB); retirements (A.01.04 and the rest) delete
  from the library and evict from the cache instead of deleting from a volume.

## Decisions taken by the user on 2026-09-14 (toolbox extension, E.00–E.08)

- **Content boundary.** No porn and no sexual acts ("i dont want to do porn or
  sexual stuff not interested never interested"). Music video, dance, nude yoga
  and classy artistic nudity are in scope. Settings, environments and costumes
  weigh as much as people and poses.
- **Scope is the toolbox audit's list, approved item by item, with two
  strikes.** (1) No model enters only for benchmarking when its licence is not
  good for Oshun's production use: Krea 2, FLUX.2 klein 9B, the ponpoke
  uncensored encoder and Anima are not pulled, and the `eval_only` distribution
  tier and the register's evaluation-grant column, which existed only for them,
  are dropped. (2) No outreach emails: no MiniMax H3 authorisation request and
  no CircleStone commercial-licence request.
- **Kept:** every tier-2 item (The Walk, regional prompting, Qwen-Image-Layered
  pulled only on a later go, Illustrious XL v2.0 listed and not pulled); the
  Uni3C file from `ewrfcas/Uni3C` (Apache-2.0 `.pth`, loaded only by the core
  node); a scoped own body-physics LoRA with a consent precondition (E.01.07);
  and the rule that the body-LoRA A/B (E.01.06) decides keep or prune for the
  sexual-leaning rows already in the library.
- **A stylised and anime lane joins the repertoire** (E.06) and stays `sfw_only`
  until an adult-appearance gate is live (E.06.01).
- **Self-hosting versus APIs is decided per lane by measurement** (E.01.05), not
  all or nothing. Hosted services refuse nudity, so `adult_ok` lanes stay
  self-hosted by construction.
- **Paid Civitai versions are never pulled; early-access versions wait** until
  the window ends (the CyberRealistic Z-Image precedent, A.03.02).

## Decisions taken under the owner's delegation on 2026-09-18 (board overhaul)

The owner's instruction that day: "where decisions are needed from me you can
make the decision based on what you think is best." Each decision below was
taken by the agent under that delegation, is recorded with its reason, and is
one line to reverse. None of them spends money or accepts a vendor's terms; the
ones that would (T.01.07's licence acceptances, any render) still ask first.

- **T.01.18 — training-data terms bind delivery, not internal use.** A weight
  whose training data carries non-commercial, research-only or unrecorded terms
  is admitted with `distribution: internal_only`: it may run on operator jobs,
  benchmarks and the director's own evaluation, and every output inherits
  `internal_only` through `evaluateThreeDDerivation`, so nothing derived from it
  reaches a tenant or the shared catalog. Tenant-facing neural 3D stays on the
  hosted Meshy lane (C1) until a candidate trained on cleared data (ABO, CC0 and
  CC BY objects, licensed captures) passes admission. Reason: evaluation and
  research use is what those terms allow, the lineage rule that contains it
  already exists (T.01.05), and it lets T.02, T.05 and milestone M1 be built and
  measured without shipping a derived asset. Reverse by restoring the refusal in
  the training-data rule.
- **ADR-0008 Q5 — one Blender operation library.** T.20's versioned Python
  operation modules and headless runner are the only place a Blender operation
  is implemented. Bellona keeps what Eve's governance needs — host enrolment,
  leases, fencing, the intent ledger — and calls those modules; it does not grow
  a second operation set. `libs/bellona/blender-agent`, `unity-agent` and
  `cross-dcc-consistency` are audited under T.21.07 before T.21.01 or Eve 5.5
  build on either side. The other eight ADR questions are engineering choices
  and are answered in the ADR under T.00.06.
- **F.00.03 (a) — 5 USD for the billed half of the controller bake-off, cheap
  candidates only.** Gemini 3.8 Flash, Kimi K3, GLM-5.3-flash, Qwen3.5-flash and
  DeepSeek V4.1 flash run under one 5 USD cap, the figure the phase 182 canaries
  used. Claude Fable 5.1 and Opus 5 stay out: CLAUDE.md forbids a frontier model
  without asking, and the ask is only worth making once F.20.02 has measured a
  department the cheap binding cannot do.
- **F.00.03 (b) — the film lane takes at most one fifth of a Codex window.** The
  plan the seat is on is a fact only the owner has, so the governor does not
  depend on it: it learns the window from the first limit response, reserves 20%
  of it, and queues film runs for 00:00–06:00 local unless a person starts one.
  The plan name is a field in the decisions record, empty until the owner fills
  it.
- **F.00.03 (c) — the pilot brief.** Forty seconds, eight shots, two characters,
  one interior set (a small workshop), one four-line dialogue exchange, one
  simulated effect (a curtain in a draught, cloth), full sound, 1920×1080 at 24
  fps, `sfw_only`, a stylised-realistic look.
- **F.00.03 (d) — native shot tracking only.** No Kitsu sync; F.03.05 is parked.
- **F.00.03 (e) — scene-linear Rec.709 with the AgX view**, from the OpenColorIO
  configuration bundled with the pinned Blender 5.2.1, pinned by hash. It needs
  no texture conversion and is what the T.10 and T.14 measurements were taken
  in.
- **F.00.03 (f) — no HDR master** for the pilot; F.19.04 delivers SDR only.

## Facts verified on 2026-09-11 (re-verify before relying on any of them)

- **RunPod account (live GraphQL/REST):** balance $15.00, spend limit $80/h
  ceiling field, zero endpoints, zero network volumes, zero pods, zero
  templates. `RUNPOD_API_KEY`, `RUNPOD_S3_ACCESS_KEY`, `RUNPOD_S3_SECRET_KEY`
  present in `~/Desktop/workspace/drawer/env-master.env`.
- **`oshunai/runpod-comfyui` and `oshunai/runpod-base` do not exist on Docker
  Hub** (404). The whole `docker/runpod/comfyui/` image lineage was never
  published. It bakes per-flavor model sets (the `comfyui-flagship-image`
  inventory lists 47 baked artifacts). That design is retired for this work.
- **Stock worker:** `runpod/worker-comfyui:5.1.0-base` accepts
  `{ input: { workflow: <API-format graph>, images?: [{name, image}] } }` and
  returns
  `{ output: { images: [{ filename, type: 'base64'|'s3_url', data }] } }`.
  Network volume mounts at `/runpod-volume`; models are read from
  `/runpod-volume/models/<comfy-folder>/…`. Custom nodes need a derived image
  (`FROM runpod/worker-comfyui:5.1.0-base` + `comfy-node-install <pack>`).
- **ComfyUI-RMBG (1038lab)** ships SAM 3 segmentation (v2.9.4, fix v2.9.5),
  BiRefNet (general/512/portrait/matting/HR/HR-matting/lite/lite-2K/Lucida) and
  RMBG-2.0. Model folders: `models/RMBG/RMBG-2.0/`, `models/RMBG/BiRefNet/`, SAM
  3 under the pack's own `models/…` folder (confirm exact path from the pack
  source in C.01.03 before writing the volume manifest).
- **Model access, anonymous HF (no account):** `lodestones/Chroma1-HD`
  (ungated), `comfyanonymous/flux_text_encoders` T5-XXL fp16, Flux
  `ae.safetensors`, `ZhengPeng7/BiRefNet-portrait`,
  `ZhengPeng7/BiRefNet-matting`, `ZhengPeng7/BiRefNet_HR-matting` (all ungated),
  `1038lab/RMBG-2.0` and `1038lab/sam3` (ungated mirrors the node pack downloads
  from). `facebook/sam3` is gated=manual and `briaai/RMBG-2.0` gated=auto — not
  needed.
- **CivitAI:** UnCanny v1.3 BF16 (17.38 GB, version 2517681) and Photonic Fusion
  Chroma Debloated (17.38 GB, version 2848934) return **401 anonymously**.
  `CIVITAI_API_KEY` (32 chars) is now in `env-master.env`. Ungated HF mirrors of
  UnCanny exist only as GGUF/DF11 (quantized/compressed) — excluded by the
  no-quantization rule.
- **Registry:** the repo already pushes to `ghcr.io/greychimp/oshun/…` from
  `.github/workflows/container-build.yml`. No Docker Hub account will be created
  (user decision 2026-09-11).
- **Pricing (runpod.io/pricing, 2026-09-11):** serverless RTX 4090 $1.10/h, L40S
  $1.75/h, RTX A5000 $0.69/h, A40 $1.22/h, RTX 5090 $1.58/h, H100 $4.79/h;
  network storage $0.07/GB/month under 1 TB; on-demand pod RTX 4090 $0.74/h,
  L40S $1.09/h.
- **Isis seams (read in full today):**
  - `apps/isis/generation-api/src/workflows/executor.ts` submits
    `workflow: workflow.id` (line ~4158) — the old handler rendered the catalog
    server-side; the stock worker needs a bare graph.
  - `libs/isis/workflows/src/templates/catalog-renderer.ts` already exports
    `renderCatalogWorkflow` (TypeScript port of the handler's renderer).
  - `libs/isis/ai-providers/src/providers/comfy/runpod-adapter.ts`:
    `translateToRunPodFormat` (~2093) sends `input.workflow` as the bare graph
    plus `inputs`/`workflowMetadata`/`metadata` (extra keys are ignored by the
    stock worker); `mapRunPodOutput` (~1531) and `RunPodJobOutput` (~1061)
    require `images[].url` — incompatible with the stock `type`/`data` shape.
  - `apps/isis/generation-api/src/services/comfyui.service.ts`: provider
    selection via `getComfyUIProvider()` (`COMFYUI_PROVIDER`), RunPod adapter
    built from `getRunPodConfig()` in `libs/shared/config/src/features.ts`
    (`RUNPOD_API_KEY`, `RUNPOD_COMFYUI_ENDPOINT_ID`, canary vars).
  - `apps/isis/generation-api/src/middleware/runpod-budget-guardrail.ts`:
    soft/hard USD limits, throttle window, fail-closed when cost unavailable.
  - `apps/isis/generation-api/src/services/job.service.ts`: BullMQ + ioredis
    (Redis required locally). Auth: `JWT_SECRET` (`src/app.ts`).
  - `libs/isis/workflows/src/workflows/<category>/<id>.json` catalog shape:
    `workflow_info`, `inputs`, `nodes`, `prompt_construction`, `aspect_map`,
    `output_spec`, `custom_nodes_required`, `models_required`; registry in
    `libs/isis/workflows/src/utils/registry.ts`; lints in `utils/*-lint.ts`.
  - `apps/isis/web`: Vite on 5180, `VITE_ISIS_GENERATION_API_URL`; pages
    `WorkflowsPage`, `JobSubmissionStudio`, `JobsPage`, `OutputsPage`,
    `RunPodPage`; Playwright config in `apps/isis/web/playwright.config.ts`
    (`E2E_BASE_URL`); client in `libs/isis/client/src/resources/*`.
  - `infra/runpod/endpoints/{desired-state,warm-cold-policy,image-build-config, image-build-manifest}.json` +
    `inventory/*.json` (schemaVersion 2).
  - `libs/isis/runpod-surface/src/{endpoint-registry,cost-quota,queue-inspector}.ts`.

## Facts verified on 2026-09-11 for the video extension (anonymous HF API + raw GitHub; re-verify before relying)

- **Wan weights, ComfyUI single-file form (all ungated):**
  `Comfy-Org/Wan_2.2_ComfyUI_Repackaged` @
  `c4f60d30c55a624e35427060fdd217579a6c1d77` —
  `wan2.2_t2v_{high,low}_noise_14B_fp16.safetensors` 28.58 GB each,
  `wan2.2_i2v_{high,low}_noise_14B_fp16.safetensors` 28.58 GB each,
  `wan2.2_animate_14B_bf16.safetensors` 34.55 GB, `umt5_xxl_fp16.safetensors`
  11.37 GB, `wan_2.1_vae.safetensors` 0.254 GB, LoRAs
  `wan2.2_{t2v,i2v}_lightx2v_4steps_lora_v1*_{high,low}_noise.safetensors` 1.23
  GB each, `wan2.2_animate_14B_relight_lora_bf16.safetensors` 1.44 GB.
  `Comfy-Org/Wan_2.1_ComfyUI_repackaged` @
  `617a7633e636506f850e043bc4605f290a466a8e` —
  `wan2.1_vace_14B_fp16.safetensors` 34.68 GB, `clip_vision_h.safetensors` 1.26
  GB. The `Wan-AI/*` originals the user named are sharded diffusers checkpoints
  (126 GB each for T2V/I2V incl. duplicates) that ComfyUI's `UNETLoader` cannot
  load; the Comfy-Org repackages are the same weights in the same precision and
  are what the manifest rows point at. `Wan-AI/Wan2.2-Animate-14B` (ungated)
  additionally hosts `process_checkpoint/det/yolov10m.onnx`, which the animate
  preprocess pack loads.
- **SAM 3.1:** `facebook/sam3.1` exists, **gated=manual**, one checkpoint
  `sam3.1_multiplex.pt` 3.50 GB. The only ungated mirror (`1038lab/sam3`) has
  `sam3.1_multiplex_fp16.safetensors` 1.75 GB (fp16 — allowed by rule 3). **No
  ComfyUI pack loads it at the pinned SHAs:** ComfyUI-RMBG `@58f1947a`
  `SAM3Segment` hard-codes `sam3.pt`; ComfyUI-SAM3 (`PozzettiAndrea`,
  `@de0ff5d2c2ea435d29f800abfa568cffdfb94773`) `LoadSAM3Model` hard-codes
  `models/sam3/sam3.safetensors`. Video tracking therefore runs on **SAM 3**
  (already on the volume) through ComfyUI-SAM3's `SAM3VideoSegmentation`,
  `SAM3Propagate`, `SAM3VideoOutput`; SAM 3.1 is a dated "no supported pack" row
  (V.12.01). ComfyUI-SAM3 ships a `comfy-env`/pixi isolated installer
  (`install.py`, `prestartup_script.py`) that must be bypassed in a Docker
  build.
- **FlashVSR v1.1:** `JunhaoZhuang/FlashVSR-v1.1` @ `27561b186ded…` ungated:
  `diffusion_pytorch_model_streaming_dmd.safetensors` 5.68 GB, `LQ_proj_in.ckpt`
  0.58 GB, `TCDecoder.ckpt` 0.19 GB, `Wan2.1_VAE.pth` 0.51 GB. Pack
  `lihaoyun6/ComfyUI-FlashVSR_Ultra_Fast`
  `@4820b3f02347bddcbbb9a5a85ab7638fe976366e` (2025-11-20) reads
  `<models_dir>/<repo tail>/` directly (not via extra_model_paths), needs
  `triton`, replaced Block-Sparse-Attention with Sparse_Sage (no kernel
  compile). Alternative pack `smthemex/ComfyUI_FlashVSR` (2026-02-23) not
  evaluated.
- **GIMM-VFI:** `Kijai/GIMM-VFI_safetensors` @ `c1089661cf9a…`:
  `gimmvfi_f_arb_lpips_fp32.safetensors` 0.123 GB, `gimmvfi_r_…` 0.079 GB,
  `raft-things_fp32.safetensors` 0.021 GB, `flowformer_sintel_fp32.safetensors`
  0.065 GB. Pack `kijai/ComfyUI-GIMM-VFI`
  `@4c9a3123762af85e7c796e41737da0b70c75d72d` (last push 2025-07-31) reads
  `models/interpolation/gimm-vfi/`, nodes `DownloadAndLoadGIMMVFIModel`,
  `GIMMVFI_interpolate`, requires `cupy-cuda12==13.3.0` (base image is CUDA
  12.8).
- **LTX-2.3:** `Lightricks/LTX-2.3` @ `5948be4ced3a4493d1f836df64378ff136ddb770`
  ungated (LTX-2 community license): `ltx-2.3-22b-dev.safetensors` 46.15 GB,
  `ltx-2.3-22b-distilled-1.1.safetensors` 46.15 GB,
  `ltx-2.3-22b-distilled-lora-384-1.1.safetensors` 7.61 GB,
  `ltx-2.3-spatial-upscaler-x2-1.1.safetensors` 1.00 GB, `…-x1.5-1.0` 1.09 GB,
  `ltx-2.3-temporal-upscaler-x2-1.0.safetensors` 0.26 GB. Text encoder is Gemma
  3 12B: `google/gemma-3-12b-it*` are **gated=manual**; the ungated
  full-precision single file is `Comfy-Org/ltx-2`
  `split_files/text_encoders/gemma_3_12B_it.safetensors` 24.38 GB (bf16; the
  fp8/fp4 variants beside it are excluded by rule 3). IC-LoRA
  `Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control` 0.65 GB ungated
  (depth/pose/edges control, follow-up).
- **ComfyUI 0.34.0 (the version inside `runpod/worker-comfyui:5.10.0-base`)
  ships every core node the video graphs need — no pack required for the
  generators:** `WanImageToVideo`, `WanFirstLastFrameToVideo`, `WanVaceToVideo`,
  `TrimVideoLatent`, `WanAnimateToVideo`, `WanAnimate2ToVideo`,
  `WanCameraImageToVideo`, `ModelSamplingSD3`, `CLIPLoader(type=wan|ltxv)`,
  `LTXAVTextEncoderLoader`, `LTXVAudioVAELoader`, `LTXVAudioVAEDecode`,
  `LTXVEmptyLatentAudio`, `LTXVConcatAVLatent`, `LTXVSeparateAVLatent`,
  `LTXVDualCFGGuider`, `LTXVImgToVideoInplace`, `LTXVAddGuide`,
  `LTXVCropGuides`, `LTXVPreprocess`, `EmptyLTXVLatentVideo`, `LoadVideo`,
  `GetVideoComponents`, `VideoSlice`, `CreateVideo`, `SaveVideo` (mp4/mkv/webm,
  h264/av1), `SaveWEBM` (vp9 keeps alpha), `LoadAudio`, `SaveAudio`. Input names
  verified:
  `WanAnimateToVideo(reference_image, face_video, pose_video, background_video, character_mask, continue_motion, continue_motion_max_frames, video_frame_offset, clip_vision_output)`,
  `WanVaceToVideo(control_video, control_masks, reference_image, strength)`,
  `WanFirstLastFrameToVideo(start_image, end_image, clip_vision_*)`.
- **Worker output contract for video (worker-comfyui 5.10.0 `handler.py`):** the
  handler collects only `node_output["images"]`. `SaveVideo` returns
  `PreviewVideo.as_dict() = {"images": [...], "animated": (True,)}`, so
  mp4/webm/mkv come back in the SAME `images[]` array as
  `{filename, type: 'base64'|'s3_url', data}`. `SaveAudio` returns under `audio`
  and is **not collected** — LTX audio must be muxed with
  `CreateVideo(images, audio)` → `SaveVideo`. Input `images[]` are posted to
  ComfyUI `/upload/image`, which writes the bytes as-is under the given name (no
  content check), so a small mp4 can travel that path.
- **Node packs (GitHub, alive 2026-09):** `Kosinkadink/ComfyUI-VideoHelperSuite`
  `@4d907bee61e92c2e65af3bd6383a4e4d356126d1`,
  `Fannovel16/comfyui_controlnet_aux`
  `@59b1fc411ede8623b2997855b8018f0b3b6cf49f`,
  `kijai/ComfyUI-WanAnimatePreprocess`
  `@0e0b6a2a555625acf4d4aefb780e27d06937132f` (nodes `OnnxDetectionModelLoader`,
  `PoseAndFaceDetection`, `DrawViTPose`, `PoseRetargetPromptHelper`; needs
  `onnxruntime-gpu`, models in `models/detection/`: `yolov10m.onnx` + ViTPose
  wholebody ONNX from `JunkyByte/easy_ViTPose` — gating/size NOT yet checked),
  `Lightricks/ComfyUI-LTXVideo` `@15d09abb…` (2.3 example graphs, optional —
  core nodes suffice for T2V/I2V).
- **Repo state relevant to video:** the catalog already holds video graphs bound
  to the RETIRED baked images and to quantized weights — `flagship/wan-video`,
  `flagship/wan-segment-chain` (Wan2.2 TI2V 5B + fp8 umt5),
  `flagship/ltx2-av-scene`, `flagship/ltx2-keyframe-interp` (LTX-2.3 distilled
  fp8 + Gemma fp4), `video/vace-video-edit` (fp8 umt5 + CausVid LoRA),
  `video/video-restore` (SeedVR2). They stay untouched and are not the
  deliverable. Inventories `comfyui-vace.json`, `comfyui-ltx2.json`,
  `comfyui-flagship-video.json` are `handlerKind: comfyui` with no
  `workflowIds`. The catalog input schema knows
  `enum,string,integer,float, boolean,image,image_batch` — no `video` type.
  `WORKER_COMFYUI_ONLY_CATEGORIES` (`executor.ts:3323`) is `{'chroma'}`.
  Job-envelope already has `text-to-video` and `image-to-video` generation
  types; nothing for video-to-video, upscale, interpolation or tracking.
  `docker/runpod/comfyui-slim/extra_model_paths.yaml` maps no `interpolation`,
  `detection`, `latent_upscale_models`, `audio_encoders`, `FlashVSR` folder.
- **Not verified today (docs page is JS-rendered):** RunPod's request payload
  limits (documented as 10 MB for `/run`, 20 MB for `/runsync`) — V.05.01
  confirms before the video-input threshold is chosen.

## Facts verified on 2026-09-13 for the arsenal expansion (HF API with sizes and LFS oids, Civitai model API with the project key, ComfyUI release notes, licence texts; re-verify before relying)

- **Hugging Face rows, all full precision, revision = `sha` of `main` on
  2026-09-13** (the manifest needs the 40-hex form; the prefixes here identify
  it): `Lightricks/LTX-2.5` @ `5e6e71018ee1756ed329b697a7b4aedc934dfce9` (gated
  `auto`, LTX-2.x community licence) —
  `diffusion_models/ltx-2.5-22b-dev-transformer-bf16.safetensors` 42.02 GB,
  `text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors` 26.26 GB (Gemma
  **4** with LTX projections; the plain `Comfy-Org/gemma-4` 23.95 GB file is not
  the encoder the LTX-2.5 template loads), `vae/ltx-2.5-video-vae-bf16` 1.47 GB,
  `vae/ltx-2.5-video-vae-conv-bf16` 1.45 GB (the template decides which),
  `vae/ltx-2.5-audio-vae-bf16` 0.36 GB,
  `latent_upscale_models/ltx-2.5-latent-{spatial,temporal}-upscaler-x2-bf16-1.0`
  1.00 and 0.26 GB, `loras/ltx-2.5-22b-distilled-lora-450-bf16` 8.90 GB (the
  distilled transformer, 42.02 GB, is not taken — V.12.03's "LoRA, not
  checkpoint" rule carries over). `Lightricks/LTX-2.5-22b-IC-LoRA-Ingredients` @
  `12040e4091ac2008d3906a594e31a7fb1ab9d546` —
  `ltx-2.5-22b-ic-lora-ingredients-0.9.safetensors` 1.31 GB (one composite
  reference sheet of characters, props and location, looped as a static video;
  Lightricks' recipe is 768×448, 121 frames, 24 fps, strength 1.0).
  `Lightricks/LTX-2.5-22b-IC-LoRA-Pixel-Spatial-Upscaler` @
  `b29c1f25902886fd40bc43db7b69e942457298d2` — 0.33 GB. **LTX-2.5 needs ComfyUI
  0.32.0** ("Add support for LTX 2.5", 2026-08-11); the image runs 0.34.0. As of
  2026-09-10 the LTX-2.5 IC-LoRA family on the hub is Ingredients,
  Water-Simulation, Cinemagraph, Decompression, Colorization, Clean-Plate,
  Deblur, Day-To-Night and Pixel-Spatial-Upscaler — **no 2.5 Union-Control or
  Motion-Track** yet; V.12.02's control LoRAs are 2.3-only.
- `Comfy-Org/Wan-Animate-2` @ `ed158470869ff31fa51cf56012dac33fb00f494b`
  (Apache-2.0, ungated; upstream `Wan-AI/Wan2.2-Animate-2-14B`, paper
  arXiv:2608.06009, released 2026-08-07) —
  `diffusion_models/wan_animate_2_bf16.safetensors` 32.79 GB and
  `diffusion_models/wan_animate_2_distill_bf16.safetensors` 32.79 GB (10 steps,
  no guidance). Its `text_encoders/umt5_xxl_fp16` and
  `clip_vision/clip_vision_h` have LFS oids `7b8850f1…` and `64a7ef76…`,
  **byte-identical to the rows already on the volume** — shared, no bytes. Its
  `vae/Wan2_1_VAE_bf16.safetensors` (`1ab9a32c…`, 0.254 GB) is a different file
  from the volume's `wan_2.1_vae` (`2fc39d31…`); Animate-1 runs on the latter,
  so it is pulled only if the Animate-2 template refuses it. The model card
  lists ComfyUI as a TODO, but ComfyUI **0.31.0** shipped "Support Wan-Animate2
  (CORE-358)" on 2026-08-08. What changes: the driving video is consumed
  directly (no ViTPose/DWPose extraction, so the whole `detection/` preprocess
  stage is bypassed), and a text-driven viewpoint decouples the output camera
  from the driving clip.
- `Comfy-Org/sam3.1` @ `f38cd62b71494b53ac2b56ca36e24f3c8d565581` (SAM licence)
  — `checkpoints/sam3.1_multiplex_fp16.safetensors` 1.75 GB. **SAM 3.1 is core
  ComfyUI** (kijai's PR #13408: `SAM3_Detect`, `SAM3_VideoTrack`,
  `SAM3_TrackToMask`, `SAM3_TrackPreview`; the template loads the file from
  `models/checkpoints/`; 0.35.0 carries a SAM3 FPN fix). This supersedes
  V.12.01's "no supported pack": the pack route was the wrong place to look.
- `Comfy-Org/SeedVR2` @ `673340c8a66db62b84e4099def7d01d337ae12dc` (Apache-2.0;
  upstream `ByteDance-Seed/SeedVR2-{3B,7B}`, one-step restoration, ICLR 2026) —
  `diffusion_models/seedvr2_3b_fp16.safetensors` 6.78 GB,
  `diffusion_models/seedvr2_7b_fp16.safetensors` 16.48 GB (a `_sharp` 7B variant
  of the same size is not taken), `vae/seedvr2_ema_vae_fp16.safetensors` 0.50 GB
  (the repo's two VAE names point at the same file). Native since ComfyUI
  **0.28.0** ("Add SeedVR2 support (CORE-6)"). Community measurement: SeedVR2
  wins on short AI-generated and compressed clips, FlashVSR on speed and long
  real footage — they are complements, not a swap.
- `Comfy-Org/z_image` @ `f2278092b6599e2907bb04cf70789d3fa114ddee` (Apache-2.0;
  upstream `Tongyi-MAI/Z-Image`, 6B, released 2026-01-27; the non-distilled base
  takes CFG and negative prompts) — `diffusion_models/z_image_bf16.safetensors`
  12.31 GB, `text_encoders/qwen_3_4b.safetensors` 8.04 GB (oid `6c671498…`),
  `vae/ae.safetensors` 0.34 GB whose oid `afc8e282…` **is the volume's existing
  `vae/ae.safetensors`** (the Flux autoencoder Chroma already uses) — shared.
  Controlnets from Alibaba PAI, both Apache-2.0:
  `alibaba-pai/Z-Image-Fun-Controlnet-Union-2.1` @
  `755999a934909bd5832e20718bb7c639d2a63eb9` —
  `Z-Image-Fun-Controlnet-Union-2.1.safetensors` 6.71 GB (a 2.02 GB `-lite` and
  a Tile variant exist) for the base;
  `alibaba-pai/Z-Image-Turbo-Fun-Controlnet-Union-2.1` @
  `5155fc56d17821007d6f62ac192c09e0f0e72016` —
  `Z-Image-Turbo-Fun-Controlnet-Union-2.1-2602-8steps.safetensors` 6.71 GB (the
  newest dated 8-step build) for the Turbo finetunes. Conditions: canny, HED,
  depth, pose, tile. Native since ComfyUI 0.26 ("Support Krea2" era; Z-Image
  itself since 2025-11). Z-Image renders nudity natively; no encoder swap is
  needed (the abliterated-encoder route exists but is unnecessary).
- `Comfy-Org/vae-text-encorder-for-flux-klein-4b` @
  `5f526678002e43af5551dadb73ce2e8c91b43afe` (Apache-2.0; upstream
  `black-forest-labs/FLUX.2-klein-4B`, Apache-2.0 — the 9B is
  flux-non-commercial) —
  `split_files/diffusion_models/flux-2-klein-4b.safetensors` 7.75 GB,
  `split_files/vae/flux2-vae.safetensors` 0.34 GB (oid `868fe7b3…`, a different
  autoencoder from `ae.safetensors`), and
  `split_files/text_encoders/qwen_3_4b.safetensors` whose oid `6c671498…` **is
  the same file as Z-Image's** — shared. Multi-reference editing in the base
  model. `ponpoke/flux2-klein-4b-uncensored-text-encoder` (abliterated Qwen3,
  layers 14–35) is licensed flux-non-commercial-v2.1 — never pulled.
- `Comfy-Org/HiDream-O1-Image` @ `de544d7b47e9b22aee77d1a56da0457dfe8d4449`
  (MIT; upstream `HiDream-ai/HiDream-O1-Image`, 8B pixel-level unified
  transformer, no external VAE or text encoder, released 2026-05-08; Dev-2604
  debuted #8 on the Artificial Analysis text-to-image arena) —
  `checkpoints/hidream_o1_image_dev_bf16.safetensors` 16.37 GB (28 steps, CFG 0;
  the undistilled 16.37 GB `hidream_o1_image_bf16` is not taken). Tasks:
  text-to-image, instruction editing, subject-driven personalization with layout
  and skeleton conditioning, up to 2048². Native ComfyUI (0.28.0 "Fix hidream o1
  regression"; 0.35.0 DiffSynth LoRA support). The base blurs skin (Comfy-Org
  discussion #5: "skin is still pure blur"); Civitai has only a `_clear_v1`
  repack and no uncensored finetune — SFW-only.
- `Comfy-Org/Qwen-Image_ComfyUI` @ `7beb7b647f04469fbe64ba8adc2bb0d7e5e9f73f`
  (Apache-2.0) — `split_files/diffusion_models/qwen_image_2512_bf16.safetensors`
  40.86 GB, `split_files/text_encoders/qwen_2.5_vl_7b.safetensors` 16.58 GB (oid
  `cfafd739…`), `split_files/vae/qwen_image_vae.safetensors` 0.25 GB (oid
  `a70580f0…`). `Comfy-Org/Qwen-Image-Edit_ComfyUI` @
  `7d41107b653d3039be20972fb82398b01b3213eb` (Apache-2.0) —
  `split_files/diffusion_models/qwen_image_edit_2511_bf16.safetensors` 40.86 GB
  (up to three reference images; 2509 and the FireRed edit model sit beside it,
  not taken). `Comfy-Org/Qwen-Image-InstantX-ControlNets` @
  `14281e338504b697e300467af940e4fbbeea4cdf` (Apache-2.0) —
  `split_files/controlnet/Qwen-Image-InstantX-ControlNet-Union.safetensors` 3.54
  GB and `…-Inpainting.safetensors` 4.23 GB. **The survey's "+65.5 GB" for this
  family was wrong — it omitted the Edit-2511 weight; the true figure is 106.32
  GB.** Under D-V5 (no quantization) 40.86 GB of transformer plus 16.58 GB of
  encoder cannot sit on the image endpoint's 24–32 GB cards: Qwen-Image runs on
  the **video endpoint** (A.02.05 adds the routing). Qwen-Image 2.0 (7B,
  Feb 2026) is API-only; the open line ends at 2512 / Edit-2511.
- `Comfy-Org/SCAIL-2` @ `3bd725f20edad6967a65792af3017e251a5bd853` (MIT;
  upstream `zai-org/SCAIL-2`, Wan2.1-14B based, "end-to-end controlled character
  animation" without pose intermediates: driving video in, cross-identity
  replacement, animal driving, multi-character, zero-shot SAM3D-Body mesh
  control) — `diffusion_models/wan2.1_14B_SCAIL_2_fp16.safetensors` 32.79 GB
  (oid `e3f9cd52…`), `loras/wan2.1_SCAIL_2_DPO_lora_bf16.safetensors` 1.23 GB,
  `loras/wan2.1_SCAIL_2_relight_lora_bf16.safetensors` 1.23 GB; umt5 and the Wan
  2.1 VAE are the volume's. Native since ComfyUI 0.26.0 ("SCAIL-2 multireference
  (CORE-310)").
- `Comfy-Org/Depth-Anything-3` @ `248c0c2c1fca3cf3046db1d0d3d5256f2d078f41`
  (Apache-2.0; upstream `depth-anything/DA3-*`) —
  `geometry_estimation/depth_anything_3_mono_large.safetensors` 1.34 GB (a
  `metric_large` 1.34 GB and `base` 0.54 GB exist). The folder is
  `geometry_estimation/`, which the manifest lint's `ALLOWED_TOP_FOLDERS` does
  not list yet (A.00.04 extends it). This replaces
  `controlnet_aux/depth-anything/Depth-Anything-V2-Large/depth_anything_v2_vitl.pth`,
  whose manifest row records **CC-BY-NC-4.0** — a licence defect on the volume
  today, not a preference.
- **Civitai rows (all `source: civitai`, `gated: true`, `auth: CIVITAI_API_KEY`;
  ids are model / version / file; flags are Civitai's `allowCommercialUse`;
  every hash is the 64-hex SHA-256 the version API returns — full values go into
  the manifest rows at A.00.04):** Chroma — NiceGirls UltraReal 1862761 /
  2487473 / 2375819, `NiceGirls_Chroma.safetensors` 224 215 935 B, sha
  `3ee48c8a…`, Image+RentCivit+Rent+Sell; NSFW Realism v1.0 1972809 / 2357084 /
  2247730, `realism3.safetensors` 1.051 GB, sha `23827806…`, all four flags;
  UnGloryHail BF16 2580292 / 2898818 / 2776781,
  `ungloryhail_bf16_2776781.safetensors` 17.383 GB, sha `9c2c9bff…`, all four
  flags (the 8.978 GB primary file of that version is fp8 — take file 2776781,
  not the primary). Z-Image — CyberRealistic Z-Image Turbo v8.0 2218365 /
  3284136 / 3168412, 12.272 GB bf16, sha `b06925b4…`, all four (the version's
  primary file is nvfp4 — take 3168412); Z-Image-Turbo-BF16-AIO 2173571 /
  2447693 / 2339157, 20.042 GB, sha `9120e2c0…`, all four (an all-in-one
  checkpoint: transformer, encoder and VAE in one file, loaded with
  `CheckpointLoaderSimple`, so nothing is shared); PhotoReal BetterNudes v3
  2174081 / 2474435 / 2365660, 170 128 224 B, sha `f1425fb7…`, all four;
  Realistic Snapshot ZIT v5 2268008 / 2617751 / 2505151, 170 127 768 B, sha
  `182d7f92…`, all four; [ZIT] Breast Slider 2230417 / 2510875 / 2398788, 0.021
  GB, sha `7c50ee82…`, all four; [ZIT] Detail Slider 2234266 / 2515203 /
  2403021, 0.021 GB, sha `a77e9496…`, all four; DetailDeamonZ v1.1 2209262 /
  2672935 / 2559725, 0.137 GB, sha `1ae0841f…`, all four (the ZIT version
  2487375 carries the identical file — one row serves both). Wan 2.2 I2V LoRAs
  ship as high-noise and low-noise files, one per expert, so every Wan entry is
  a pair: Camera Tilt-down Undershot V2 1889070 — high 2151623 / 2044994 (0.300
  GB, `ceb11105…`), low 2151680 / 2045016 (306 807 976 B, `f90158fd…`), all four
  flags; Camera Tilt-up Overhead v1.1 1878750 — high 2126493 / 2020538 (0.599
  GB, `5e073237…`), low 2126538 / 2020573 (613 516 752 B, `c1d7a183…`), all
  four; Hip sway Type1 2371603 — high 2667225 / 2554025 (306 807 976 B,
  `8cdd296b…`), low 2667138 / 2554013 (0.300 GB, `badb231a…`), all four; Hip
  Bump Dance 2120562 — high 2398829 / 2289180 (0.300 GB, `ddb79ca2…`), low
  2398838 / 2289193 (306 808 368 B, `75fc2066…`), Image+RentCivit+Rent (no Sell,
  which is irrelevant here); [Wan2.2] Breast slider v2 1971502 (trained on T2V,
  same experts) — high 2235351 / 2128288 (38 436 176 B, `752c4925…`), low
  2235403 / 2128297 (0.038 GB, `66be876a…`), all four. **Internal-only Wan pairs
  (Image + RentCivit, no Rent):** NSFW Posing Nude v2 1648982 — HN 2391828 /
  2282070 (306 850 360 B, `3da32a0d…`), LN 2391829 / 2281998 (306 850 720 B,
  `40f0deb6…`); Bouncing Boobs 1343431 — high 2191217 / 2084187 (306 847 512 B,
  `a4f43980…`), low 2191270 / 2084219 (306 847 504 B, `3ba83201…`) (that model's
  latest version is a MiniMax H3 file — the Wan 2.2 pair is older, pin it by
  version id); Twerking 1953874 — I2V high 2363074 / 2253843 (0.300 GB,
  `a6531ac2…`), low 2363087 / 2253850 (306 808 368 B, `b8d4a26d…`); Slow Twerk
  2055033 — high 2325622 / 2215765 (306 808 512 B, `2f43ac74…`), low 2325629 /
  2215776 (0.300 GB, `9b96ba7d…`). **Instagirl WAN 2.2 (1822984) cannot be
  pulled:** every version (2180477 v2.5 2.465 GB, 2115311 v2.3 0.549 GB) is a
  Diffusers `.zip`, which the lint rejects and `LoraLoaderModelOnly` cannot
  read; listed, not pulled (A.03.05). **The Civitai model API returns the newest
  version first, and for the multi-base LoRAs that is now Krea 2, LTX 2.3 or
  MiniMax H3** — every row above pins the Chroma / Z-Image / Wan 2.2 version by
  id for that reason.
- **Already on the manifest since the morning's C.12.01 / V.12.02 / V.12.03 work
  (lint: 50 rows, 367.17 GB):** the four C.12.01 Chroma LoRAs (Lenovo UltraReal
  Chroma 2299345 / 2190290, 112 125 552 B, `df934b1a…`; Realistic Slider 2259125
  / 2151331; Defluxer 2482626 / 2371171; Muk v1.1 2715471 / 2601052, 74 820 484
  B, `19ec8649…`), the LTX-2.3 distilled LoRA and the two LTX-2.3 IC-LoRAs. None
  of the existing LTX rows is marked gated; the LTX-2.5 repos answer
  `gated: auto`, so their rows carry `gated: true` and `auth: HF_ACCESS_TOKEN`
  and the loader sends the token (A.01.01 checks the loader's HF auth path
  before the pull).
- **Shared-file identities proved by LFS oid, not assumed:** `ae.safetensors`
  (Z-Image = volume, `afc8e282…`), `qwen_3_4b.safetensors` (Z-Image = klein 4B,
  `6c671498…`), `umt5_xxl_fp16` and `clip_vision_h` (Animate-2 = volume). Not
  shared: the FLUX.2 VAE, the Qwen-Image VAE and encoder, Animate-2's bf16 Wan
  VAE, LTX-2.5's Gemma 4.
- **Licence and territory texts read on 2026-09-13:** LTX-2.x community licence
  `LICENSE-2_x` (2026-08-11) §2.1 — free below $10 000 000 annual revenue; its
  "Outputs … agree to comply with the Acceptable Use Policy" clause incorporates
  Lightricks' AUP (2026-03-30), whose "Do Not Generate Sexually Explicit
  Content" section bans depicting "sexual intercourse or sex acts" and "sexual
  fetishes or fantasies", whose API section bans applications with "sexually
  explicit or suggestive content", and which also requires that commercially
  used output "does not replicate any real-world likeness, person, brand, or
  location unless independently cleared" (the consent registry, C.12.14, already
  enforces this). Krea 2 community licence §2.3 — commercial use only under $1
  000 000 trailing-twelve-month revenue — and §4.2 — "You must implement
  reasonable and appropriate Content Filter measures … such as
  Falconsai/nsfw_image_detection, NudeNet". Tencent Hunyuan community licences
  (HunyuanVideo, 1.5, HunyuanImage-3.0, Hunyuan3D): "Territory … excluding the
  territory of the European Union, United Kingdom and South Korea". MiniMax H3
  community licence: same exclusion (US, EU, UK, South Korea). Anima:
  CircleStone Labs Non-Commercial License. Chroma1-HD: Apache-2.0, trained
  without a safety filter, T5-only encoder (no refusal layer). Wan 2.2, Z-Image,
  SeedVR2, SCAIL-2 (MIT), HiDream-O1 (MIT), klein 4B: no acceptable-use clause.
- **ComfyUI native support by release** (from the release notes of 0.26.0 →
  0.35.0): Krea 2, SCAIL-2, Boogu-Image 0.26.0 (2026-06-23); SeedVR2, HiDream-O1
  fix 0.28.0 (07-15); Uni3C controlnet for Wan, MageFlow, Wan-Dancer batch fix
  0.29.0 (07-29); MiniMax-H3 0.30.0 (08-03); **Wan-Animate2 0.31.0 (08-08)**;
  **LTX 2.5 0.32.0 (08-11)**; Pixal3D, TRELLIS.2, SAM3D-Body 0.34.0 (08-26, the
  pinned version); Pixal3D multiview, SAM3 FPN fix 0.35.0 (09-09).
  `runpod/worker-comfyui` 5.10.0 (2026-09-01) is the newest release and pins
  0.34.0 — no base bump is needed for anything in this expansion.
- **RunPod network volume pricing (docs.runpod.io, 2026-09-13):** "First 1 TB:
  $0.07/GB/month. Beyond 1 TB: $0.05/GB/month" — tiered on the portion above 1
  TB, not a whole-volume rate; "Volume size can be increased later but cannot be
  decreased"; at $0 balance "Pods with an attached network volume are stopped
  and your data is preserved", but "if your balance stays at $0 and these
  charges can't be covered, the network volume may eventually be terminated and
  its data cannot be recovered" (no grace period is stated). Account at 09:40Z:
  balance **$9.13**, spend $0.049/h (500 GB volume only), both endpoints at
  workersMax 1 / 0 workers, no pods.

## Facts verified on 2026-09-13 for the model library and cache (Hetzner docs, a live bucket listing, the repo's loader and provision scripts; re-verify before relying)

- **Hetzner Object Storage** (docs.hetzner.com, read 2026-09-13): the base price
  "is charged per hour with a monthly price cap, regardless of how many Buckets
  you have and how many different projects or locations they are in" — the
  included 1 TB of storage and 1 TB of egress are **per account**, so
  `isis/outputs/` and the library share them; beyond the allowance storage is
  €0.0067/TB-hour and egress €1.00/TB; ingress, API calls and traffic inside the
  `eu-central` network zone are free. Locations fsn1, nbg1, hel1. **Single PUT
  limit 5 GB**, part limit 5 GB, 10 000 parts, 5 TB per object; 750 requests/s
  per source IP and per bucket; up to 10 Gbit/s per bucket. So every weight
  above 5 GB (most of the library) needs multipart on Hetzner — a different S3
  implementation from RunPod's volume API, whose multipart completion failed on
  2026-09-13 (commit `45c41ce1faf`).
- **The bucket:** `HETZNER_APP_DEV_S3_ENDPOINT` = `hel1.your-objectstorage.com`,
  bucket `app-dev-server` (both names in the key drawer; the access key is 20
  chars and the secret 40). An authenticated listing through the repo's own
  SigV4 helper at about 12:55Z returned **0 objects** at the root, under `isis/`
  and under `isis/outputs/` — the whole account allowance is free today.
  Helsinki to EU-RO-1 throughput has **never been measured**; the only measured
  transfer is Hugging Face to a RunPod CPU pod at 86.7 MB/s (V.02.04). Every
  wait time quoted before L.00.01 runs is an estimate from that figure.
  **Measured by L.00.01 on 2026-09-13 (17.8 GB, CPU pod in EU-RO-1 ↔ hel1): up
  23.9 MB/s single-stream, 37.8 MB/s with 8 parts; DOWN 13.5 MB/s single-stream,
  20.8 MB/s with 8 parts.** Downloads are the cache's rate, so the waits are:
  pinned core 212.26 GB ≈ 2.8 h at 8 parts; LTX-2.3 80.37 GB ≈ 64 min; Animate
  35.99 GB ≈ 29 min; VACE 34.68 GB ≈ 28 min; controlnet_aux 1.69 GB ≈ 1.4 min;
  RMBG-2.0 0.88 GB ≈ 43 s. Seeding the 367.17 GB library ≈ 2.7 h at 8 parts. The
  dry-run estimate reads `ISIS_RUNPOD_CACHE_SYNC_MB_PER_SECOND`, set to 20.8 in
  the runbook recipe; a higher part count may lift it (the seed runs at 16 to
  find out).
- **Loader and provision scripts as they are:**
  `runpod-provision.mjs pod create-loader` builds the pod body with the manifest
  and the loader injected as base64 env and the Civitai key as env, redacted in
  `--dry-run` output (any env name matching `KEY|TOKEN|SECRET|B64`);
  `runpod-volume-loader.py` reads `MANIFEST_B64`, downloads Hugging Face and
  Civitai rows to the mounted volume, skips a file whose sha256 already matches,
  and verifies every download. It has no S3 client and no Hetzner mode. No
  `aws`, `rclone`, `mc` or `s5cmd` exists on the Mac. `runpod-volume-s3-put.mjs`
  exports a SigV4 `listObjects` that worked against Hetzner unchanged when given
  an endpoint, region `hel1`, bucket and keys through `resolveConfig` overrides.
- **Cost arithmetic:** cache volume 400 GB × $0.07 = **$28.00/month**; while it
  and the 1024 GB volume both exist, $99.20/month ($0.136/hour). After migration
  the storage bill falls by $43.20/month. First-month Hetzner egress: core sync
  212.26 GB plus the download-verify pass over the non-core rows (about 155 GB,
  L.01.05) is about 367 GB, inside the included 1 TB.

## Facts verified on 2026-09-14 for the toolbox extension (HF API with sizes and LFS oids, Civitai version API with the project key, licence texts read verbatim, the worker's object-info snapshot; re-verify before relying)

- **Node classes already in the worker image** (object-info snapshot
  `infra/runpod/endpoints/node-classes/worker-comfyui-5.10.0-video.json`, build
  b5376e6b): `TextGenerate` (optional image, video and audio inputs, a
  `thinking` toggle), `TextGenerateLTX2Prompt`, `LTXVGemmaEnhancePrompt`,
  `WanDancerEncodeAudio`, `WanDancerVideo`, `WanDancerPadKeyframes`,
  `WanSoundImageToVideo`, `WanSoundImageToVideoExtend`, `WanHuMoImageToVideo`,
  `WanUni3CControlnetApply`, `WanCameraImageToVideo`,
  `EmptyQwenImageLayeredLatentImage`, `ConditioningSetMask`, `ColorTransfer`
  (`reinhard_lab`, `mkl_lab`, `histogram`), `ImageCropToMask`, `CropByBBoxes`,
  `ImageCompositeMasked`, `SAM3_Detect`; `CLIPLoader` offers the `lumina2` type.
  No E item needs an image rebuild; each is weights plus catalog work.
- **Hugging Face rows** (revision = `sha` of `main` on 2026-09-14; sizes are
  byte counts; sha256 is the LFS oid):
  - `Wan-AI/Wan-Dancer-14B` @ `85ce88dd8d025459dcf0fe93982d6da8b9002957`
    (Apache-2.0, released 2026-07-13): `global_model.safetensors` 34 490 546 744
    B, `d0f15c77…`; `local_model.safetensors` 34 490 546 744 B, `7dda4250…`.
    Both headers were read by ranged request: 1 424 tensors each, **all BF16**,
    about 17.25B parameters each, native Wan key names
    (`blocks.0.cross_attn.k_img…`). `Comfy-Org/Wan-Dancer` @ `b953ccdf…` ships
    only `fp8_scaled` 18.34 GB files, which D-V5 rejects. The ComfyUI template
    also loads umt5, CLIP vision H, a Wan 2.1 VAE and the lightx2v LoRA below,
    and renders 149 frames at once. Trained genres: Chinese classical, K-pop,
    street, tap, Latin.
  - `Kijai/WanVideo_comfy` @ `8260d429d19fd7a72304cad059160b95d843913f` (no
    licence tag; an extraction from Apache-2.0
    `lightx2v/Wan2.1-I2V-14B-480P-StepDistill-CfgDistill-Lightx2v`):
    `Lightx2v/lightx2v_I2V_14B_480p_cfg_step_distill_rank64_bf16.safetensors`
    738 005 744 B, `85c4a61c…`.
  - `Comfy-Org/Wan_2.2_ComfyUI_Repackaged` @
    `c4f60d30c55a624e35427060fdd217579a6c1d77` (Apache-2.0):
    `split_files/diffusion_models/wan2.2_s2v_14B_bf16.safetensors` 32 591 643
    778 B, `a61c103c…`;
    `split_files/audio_encoders/wav2vec2_large_english_fp16.safetensors` 630 997
    322 B, `f0017a43…`.
  - `Comfy-Org/HuMo_ComfyUI` @ `3a5e6947d865c3910cb2407cf2dac6a8df506b5a`
    (Apache-2.0): `split_files/diffusion_models/humo_17B_fp16.safetensors` 34
    113 566 032 B, `0c0fcb0d…`;
    `split_files/audio_encoders/whisper_large_v3_fp16.safetensors` 3 087 130 976
    B, `a8e94b85…`.
  - `ewrfcas/Uni3C` @ `fca895f7fb454f4dfed43956cab09180d0946318` (Apache-2.0):
    `controlnet.pth` 3 991 711 400 B, `57eb4f73…` (a pickle; trained on Wan 2.1
    I2V; native `WanUni3CControlnetApply` since ComfyUI 0.29.0).
  - `fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA` @
    `e3066224ab74263f4a5b6179cd1a3b0a15577e44` (Apache-2.0):
    `qwen-image-edit-2511-multiple-angles-lora.safetensors` 295 140 688 B,
    `42426ded…`, the same file as Civitai 2300308, whose flags are Image only.
    96 poses: 4 elevations × 8 azimuths × 3 distances.
  - `lightx2v/Qwen-Image-Edit-2511-Lightning` @
    `d74eba145674fd7e31b949324e148e21e7118abd` (Apache-2.0):
    `Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors` 849 608 296 B,
    `22226e8d…`; `Qwen-Image-Edit-2511-Lightning-8steps-V1.0-bf16.safetensors`
    849 608 296 B, `a9e81a58…`.
  - Trained on Edit-2509, so a render on 2511 decides:
    `lovis93/next-scene-qwen-image-lora-2509` @
    `9b9da698b8a5370efd875f18b1727cc1119f3863` (MIT)
    `next-scene_lora-v2-3000.safetensors` 295 146 176 B, `8abf2306…`;
    `dx8152/Qwen-Image-Edit-2509-Relight` @
    `f0d2f0b55c7b222c425ca3a7bf80ae7110bf2aae` (Apache-2.0)
    `Qwen-Edit-Relight.safetensors` 236 117 032 B, `2a11c2b7…`;
    `dx8152/Qwen-Edit-2509-Light-Migration` @
    `402a49e4afaf739e7dc21da3549ae9353db9759b` (Apache-2.0)
    `参考色调.safetensors` 236 117 032 B, `202d76cf…` (non-ASCII filename).
  - `Comfy-Org/Qwen-Image-Layered_ComfyUI` @
    `f06012b5c1951a65d5c98ba24bd67103167b60c0` (Apache-2.0):
    `split_files/diffusion_models/qwen_image_layered_bf16.safetensors` 40 861
    043 888 B, `736a424a…`; `split_files/vae/qwen_image_layered_vae.safetensors`
    253 816 616 B, `c5320595…`.
  - `duongve/NetaYume-Lumina-Image-2.0` @
    `69c29c441119d43405d8373c654b16827d3cf46e` (Apache-2.0, Lumina Image 2.0
    base): `NetaYume_v4_all_in_one.safetensors` 10 620 229 821 B, `e2b277ee…`.
  - `OnomaAIResearch/Illustrious-XL-v2.0` @
    `69459c1fe6f46db41ab31e6114f05acc0e06bcaa` (CreativeML OpenRAIL-M; v1.1
    carries the SDXL licence and only v0.1 the Fair AI Public License):
    `Illustrious-XL-v2.0.safetensors` 6 938 040 674 B, `c2a1a3ea…`.
- **Civitai rows** (model / version / file; flags from the model API; sizes are
  the version API's kilobytes × 1024, to be confirmed by a one-byte ranged
  download at row time as A.00.04 did; sha256 from the version API). None of
  these versions has a `paidAccess` value; a non-null one marks a paid version,
  as on Zenith 3319176 and Galena Blend 3290546, whose downloads answer 403. The
  Walk 1363473 / 2254373 / 2146812 (High-Normal, 306 847 696 B, `b2f5b82d…`) and
  1363473 / 2254403 / 2146819 (Low-Normal, 306 847 696 B, `4d44292a…`), all four
  flags, triggers walking, walking back, walking front, walking side. Anyone
  Cosplay 2435164 / 2738032 / 2624308 (Edit 2511, 472 047 336 B, `b1283ff2…`),
  all four. Clothes Try On 1940532 / 2196278 / 2089342 (295 146 168 B,
  `74160619…`), Outfit Extractor 1940557 / 2196307 / 2089371 (295 146 184 B,
  `c19caefa…`), Pose Transfer v2 1959609 / 2221229 / 2115154 (295 146 184 B,
  `ba0687e4…`), all three Edit-2509-era, all four flags. AfterDark v2.0-ZIT
  2176378 / 2470291 / 2358915 (170 128 312 B, `5deef505…`, Image+RentCivit+Rent,
  trigger `4ft3rd4rk`). GrainScape UltraReal ZIT 1332651 / 2460872 / 2349334 (85
  094 848 B, `cd581ff4…`, all four). Movie Wide Angle 2186574 / 2462010 /
  2350529 (170 128 240 B, `3cabfc6d…`, all four). [ZIT] Light Slider 2262501 /
  2546755 / 2435039 (876 696 B, `9d450642…`, all four). Cinematic Shot ZIT
  432586 / 2454927 / 2345047 (170 128 240 B, `aad0ac36…`, Image+RentCivit).
  Velvet's Mythic Fantasy Styles 599757, all four flags: Detailed Anime 2504197
  / 2392210 (170 127 768 B, `99a6767b…`, `D3tailed4nime`), Anime Lines 2466747 /
  2355335 (170 127 768 B, `048c23ae…`, `An1meL1nes`), Gothic Lines 2924569 /
  2803185 (170 129 464 B, `96e6c9a2…`, `G0thicL1nes`), Realistic Fantasy 2547883
  / 2436183 (170 127 768 B, `b4ed5275…`, `R3alisticF`). Anime Flat Style
  1952560, all four: Qwen 2512 2559263 / 2447639 (295 146 160 B, `df41bc1c…`),
  ZiT Clean 2455064 / 2345125 (85 094 784 B, `ba79f77f…`). Flat Color Style
  1132089, Image+RentCivit+Rent: Z-Image base 2637093 / 2525125 (174 083 128 B,
  `8cbc5544…`, triggers flat color, no lineart), ZiT 2616765 / 2504174 (174 083
  128 B, `b9875b45…`), Qwen 2143914 / 2037657 (590 058 432 B, `7cf4436a…`,
  trained before 2512); its HiDream version targets HiDream-I1, not O1.
  Character Design Sheet ZiT 100435 / 2500612 / 2388655 (170 127 760 B,
  `b316b482…`, all four, trigger `CharacterDesignIZT`). Dark Art Style 1380736,
  Image+RentCivit+Rent: Chroma 2320313 / 2210571 (14 186 264 B, `08a6d6fb…`),
  ZiT 2467722 / 2356358 (170 128 256 B, `6efe7284…`), trigger `dark_art_style`.
  Retro Sci-fi 90s 912942, Image+RentCivit+Rent: Chroma 2326231 / 2216400 (14
  168 760 B, `dc50f6c6…`), ZiT 2463751 / 2352300 (170 128 280 B, `4a61e425…`).
  Aesthetic Quality Modifiers 929497, Image+RentCivit+Rent: ZiT 2622701 /
  2510297 (174 083 128 B, `3976b7e3…`), Qwen 2241189 / 2133899 (590 058 432 B,
  `b059142d…`, trained before 2512). LTX-2.5 3D Animation 2895989 / 3273961 /
  3157911 (674 249 632 B, `ce2a0d7a…`, Image+RentCivit+Rent, trigger `3dsrx`).
- **Licence texts read verbatim on 2026-09-14.** Krea 2 Community License v1
  (2026-06-22): §2.1 a revocable worldwide grant; §2.3 commercial use of the
  model, derivatives **and outputs** only below USD 1 000 000 company-wide
  trailing twelve-month revenue including affiliates, ceasing when crossed; §4.2
  filters against "prohibited, harmful, or unlawful content through your
  deployment"; §9.2 termination "for any reason" on 30 days' notice; no seat cap
  in the text. The Krea 2 acceptable-use policy prohibits CSAM, non-consensual
  intimate imagery and third-party rights violations and does not ban consensual
  adult nudity. MiniMax H3 Community License (2026-08-02): scope "expressly
  limited to the Applicable Territory", Excluded Territories the EU, the UK,
  Korea and the USA; its acceptable-use exhibit has no adult-nudity ban. Pony V7
  (`pony-license`): no inference service or application, no company above USD 1M
  revenue, no professional video production. NoobAI-XL: Fair AI Public License
  1.0-SD plus a no-commercialisation term. NewBie-image: `newbie-nc-1.0`. FLUX.2
  klein 9B and Anima non-commercial licences permit for-profit testing in a
  non-production environment (recorded; not used, per the decisions above). UK
  Coroners and Justice Act 2009 s.62 criminalises non-photographic sexual images
  of children, drawn images included.
- **Comparative evidence (independent, not measured here):** MiniMax H3 leads
  open models on complex action and reference-driven camera, LTX-2.5 on speed,
  resolution and multishot (August 2026 comparisons); a June 2026 anime
  comparison ranks Anima > NewBie ≥ NetaYume > RouWei-Gemma >> SDXL models, with
  NetaYume reading as painterly; a 295-prompt test gives Z-Image the realism
  edge over Krea 2. These shape E.01's benchmark; they are not results.
- **Prompt tooling today:** `libs/isis/prompt-engineering` scores LLM prompt
  templates and no `apps/isis` code imports it. HiDream-O1's template refine
  step passes an empty prompt when the model's reply is not the expected JSON
  (A.02.03), which is why E.02 fails loud. The Easy Krea 2 workflow's "prompt
  enhancer" is core `TextGenerate` on the model's own Qwen3-VL-4B encoder; the
  MiniMax H3 character-replacement v3 workflow captions the reference identity
  and the driving clip's action with Qwen3-VL. Z-Image publishes `pe.py` as its
  prompt-enhancer template.
- **Library at scoping:** 813.38 GB of the 900 GB alarm line after the arsenal
  pull (A.00.03), before later retry pulls landed; A.05.03's pending retirements
  total 117.71 GB (LTX-2.3 80.38, Animate-1 35.99, Depth-Anything-V2 1.34).
  Re-read the bucket before E.00.02.

## Non-negotiable rules for this initiative

1. **Cost is bounded by configuration, not by attention.** Endpoint
   `workersMax: 1`, `workersMin: 0`, execution timeout ≤ 300 s for image
   workflows (≤ 900 s for video workflows, on their own endpoint — V.03), idle
   timeout ≤ 15 s, and an API-side daily USD budget that fails closed (HTTP
   429/503, never a silent drop) — all four must be in place before the first
   real job is submitted from the dashboard.
2. **No model baking.** Worker image = ComfyUI + node packs only. Models live on
   the network volume under ComfyUI's folder layout. Adding a model is a copy to
   the volume plus a manifest row; it never triggers an image rebuild.
3. **No quantization.** BF16/FP16 weights only, one shared T5 + VAE. GGUF, DF11,
   fp8, int8 variants are out of scope even when they are the only ungated
   mirror.
4. **No new accounts, no public image.** GHCR (GitHub Container Registry, where
   this repo already pushes its other images) holds the worker image as a
   PRIVATE package. RunPod pulls it through a registry credential: the GitHub
   username plus a fine-grained personal access token with read-packages scope
   only, stored in `env-master.env` as `GHCR_PULL_TOKEN` and attached to RunPod
   as a Container Registry Auth via the API. Anonymous HF where ungated, the
   user's CivitAI key for the two CivitAI-only checkpoints.
5. **Machine limits bind.** Image builds run on GitHub Actions, never on the 16
   GB Mac. Model downloads run on a short-lived RunPod loader pod writing
   straight to the volume, never through the Mac. One Vite/tsx server per
   session, killed at session end (`CLAUDE.md`).
6. **Honest results only.** Cost figures come from RunPod's returned
   `executionTime`/`delayTime` × the configured per-second rate; never from a
   sticker estimate presented as measured. Cold starts are billed and shown as
   such. A workflow that has not produced a real image stays `[ ]`. For the
   video extension the bar is the V.11 proof matrix (user decision 2026-09-11):
   every `motion` graph must pass the three offline proofs (golden fixture,
   static validation against the object-info snapshot, ComfyUI's own validator
   in CI); only the eight tiny live clips listed in V.11 are rendered, and every
   workflow carries a `proof_level` that says which of the two it reached.
7. **Test/harness binding:** any LLM leg (none expected here) binds
   `deepseek/deepseek-v4-flash-0731` via OpenRouter per `CLAUDE.md`. Playwright
   chromium only, `workers=1`.
8. **Keep the old handler contract intact** behind a worker-kind flag so the
   existing `docker/runpod/comfyui` path is not broken, only bypassed.
9. **Diagnose the endpoint before you blame the image** (learned the hard way,
   2026-09-11; applies to the video endpoint in V.03 too). C.12.12 spent most of
   a day recorded as "the slim worker image fails at container create", and two
   sessions built around that belief — an interim stock-image endpoint, a
   template start-command workaround, a proposal to rebuild, and a proposal to
   migrate datacenters. **The image was fine the whole time.** The endpoint had
   stopped placing workers after a GraphQL `saveEndpoint` call, and a re-save of
   the identical configuration through the console's **Manage → Edit endpoint →
   Save Endpoint** form fixed it in under a minute. The checks, in this order,
   before any rebuild/recreate/migrate:
   - `GET /v2/<ep>/health` — **zero workers in _every_ state** (not even
     `initializing` or `throttled`) while a job sits `IN_QUEUE` means the
     endpoint is not scheduling. That is an endpoint fault, never an image
     fault: an image that cannot start still produces a worker that fails.
   - Re-save the config in the console. A REST `PATCH` does **not** revive a
     wedged endpoint; GraphQL `saveEndpoint` is what wedges it. Never call
     `saveEndpoint` on a git-integration endpoint.
   - Only then suspect the image, and prove it with the model-free probe
     (`EmptyImage` → `SaveImage`, no models loaded, ~$0.03 if a worker boots and
     $0.00 if none does) rather than a full Chroma render.
   - **Do not read "Low Supply" as "no capacity".** The edit dialog labelled
     EU-RO-1's pools Low Supply / Unavailable while that datacenter placed a
     worker in ~40 s. Capacity is disproved by a queued job with zero workers
     over time, not by a label.
   - **Migrating datacenters is not a fix for a config fault.** A network volume
     cannot move, so migration means a second 500 GB volume (~$35/month) plus
     re-seeding ~70 GB through a new loader pod. Only consider it after repeated
     real placement failures on a healthy, re-saved endpoint.

## Cost model (baseline, revisit after C.11 measurements)

| Item                                     | Basis                                   | Figure             |
| ---------------------------------------- | --------------------------------------- | ------------------ |
| Network volume 500 GB                    | measured `currentSpendPerHr`            | $0.049/h           |
| **chroma-txt2img, new checkpoint, warm** | **measured** 10.1 s + 180.9 s (C.11.02) | **$0.0584**        |
| **chroma-txt2img, checkpoint resident**  | **measured** 1.1 s + 104.4 s (C.11.03)  | **$0.0323**        |
| **chroma-txt2img, cold start**           | **measured** 53.3 s + 150.1 s (C.11.01) | **$0.083**         |
| **chroma-img2img**                       | **measured** 0.1 s + 218.0 s (C.11.05)  | **$0.0668**        |
| **chroma-inpaint, model resident**       | **measured** 0.1 s + 24.9 s (C.11.06)   | **$0.0077**        |
| **chroma-txt2img-then-matte**            | **measured** 0.1 s + 35.1 s (C.11.10)   | **$0.0108**        |
| **matting (BiRefNet), any of the three** | **measured** 7.2–10.0 s (C.11.07 b/c/d) | **$0.0022–0.0031** |
| Cold boot of a worker (no model load)    | measured 78.9 s (C.12.12 probe)         | $0.024             |
| SAM 3 segment                            | runtime landed 2026-09-12 (C.12.18)     | unmeasured         |

**What the measurements changed.** The old estimates put a warm Chroma render at
~$0.011 and a cold one at ~$0.028; both were roughly 3–5x too low. The reason is
that GPU time is dominated not by sampling but by **loading a 17.4 GB checkpoint
from the network volume on every container start** — 26 steps at 1024² is ~45 s
of the 180 s. The cheap cases are the ones where the model is already resident
(inpaint at $0.0077, matte at $0.0108) and the small-model workflows (BiRefNet
matting at a third of a cent). **Batching is not a saving**: two 896×1152
latents beside the checkpoint killed ComfyUI outright (C.11.04). A realistic day
of 20 mixed renders is therefore ~$1.00–1.30 plus $0.049/h of volume, not the
~$15/month the original table implied.

Full-precision disk footprint: Chroma1-HD 17.8 GB + UnCanny 17.38 GB + Photonic
17.38 GB + T5-XXL fp16 9.79 GB + VAE 0.17 GB + SAM 3 3.45 GB + BiRefNet 0.44 +
0.885 + 0.885 GB + RMBG-2.0 0.885 GB ≈ **69 GB**. Provision 100 GB; RunPod
volumes grow but never shrink.

## Suggested order for "usable today"

C.00 → C.01 (kick off CI build, it runs unattended) → C.02 (volume + loader pod,
runs unattended) → C.04 (cost controls) → C.05 → C.06 → C.07 → C.08.01 only →
C.10 → C.03 (endpoint, once the image is on GHCR) → C.11.01 (first real image) →
C.09 (dashboard polish) → remaining C.08 workflows → rest of C.11.

---

## C.00 Phase control, evidence, and tracker rules

- [x] **C.00.01** Add this file to `TODOS/index.md` under a new "Initiative
      trackers" line (do not renumber phases). Commit + two-line push.
- [x] **C.00.02** Create `docs/agents/isis-chroma-runpod-evidence.md` with one
      dated section per checklist item that produces a live artifact (endpoint
      id, volume id, job ids, measured seconds, measured USD). Every `[x]` in
      sections C.02, C.03, C.11 must cite a row in this file.
- [x] **C.00.03** Create the throwaway env-sourcing recipe
      `/tmp/isis-chroma-env.sh` pattern (documented, not committed): exports
      `RUNPOD_API_KEY`, `RUNPOD_S3_*`, `CIVITAI_API_KEY`, `GHCR_PULL_TOKEN`,
      `JWT_SECRET`, `REDIS_URL`, `COMFYUI_PROVIDER=runpod`,
      `RUNPOD_COMFYUI_ENDPOINT_ID`, guardrail vars from C.04, cost-rate vars,
      worker-kind flag from C.06. Verify keys by length only. Delete at session
      end.
- [x] **C.00.04** Record a memory note (`memory/isis-chroma-runpod-mvp.md`) with
      the endpoint/volume ids, the worker-kind flag name, the budget env names,
      and the "never bake models" decision so future sessions do not resurrect
      the flavor images.

## C.01 Slim ComfyUI worker image (no model baking)

> **User decision 2026-09-11 (binding, supersedes "on GHCR" in this section's
> original title):** no GHCR, no image registry of our own. **RunPod is
> connected directly to the GitHub repository** and builds the worker image
> itself from `docker/runpod/comfyui-slim/Dockerfile` on branch
> `runpod-comfyui-slim` (endpoint `6l1f3tku7z2zoy`, repo-root build context).
> Items below that exist only to publish to GHCR are closed as superseded, not
> as delivered work.

- [x] **C.01.01** Create `docker/runpod/comfyui-slim/Dockerfile`:
      `FROM runpod/worker-comfyui:5.1.0-base` (pin by tag AND digest once
      resolved), `RUN comfy-node-install comfyui-rmbg` pinned to a specific
      ComfyUI-RMBG git SHA (≥ v2.9.5), plus the pack's `requirements.txt`. No
      model downloads, no secrets, no `MODELS_PATH` bake. Record the resolved
      SHAs into `/opt/oshun/build-manifest/` exactly as the old Dockerfile did.
- [x] **C.01.02** Add `docker/runpod/comfyui-slim/README.md` stating the
      contract: models from `/runpod-volume/models/…`, input/output JSON shapes
      of the stock worker, the env vars the worker honours
      (`COMFY_POLLING_MAX_RETRIES`, `COMFY_POLLING_INTERVAL_MS`,
      `BUCKET_ENDPOINT_URL` family, `WEBSOCKET`), and the rule "custom nodes →
      rebuild; models → volume copy".
- [x] **C.01.03** Read the ComfyUI-RMBG source at the pinned SHA and write down
      (in the README and in C.02's manifest) the exact model folder and file
      names it loads for: RMBG-2.0, BiRefNet-portrait, BiRefNet-matting,
      BiRefNet_HR-matting, SAM 3 (image + text-prompt path), so the volume can
      be pre-seeded and the worker never downloads at request time (downloads at
      request time are billed GPU seconds).
- [x] **C.01.04** Add `.github/workflows/runpod-comfyui-slim.yml`: manual
      `workflow_dispatch` + push-path trigger on
      `docker/runpod/comfyui-slim/**`; buildx linux/amd64; login to GHCR with
      `GITHUB_TOKEN`; tags
      `ghcr.io/greychimp/oshun/runpod-comfyui-slim:{sha,date,latest}`; expose
      the image digest as a job output and write it to the run summary.
      **SUPERSEDED 2026-09-11 (user decision): no GHCR.** RunPod builds the
      image directly from the connected repository, so nothing needs to publish
      to a registry. The file `.github/workflows/runpod-comfyui-slim.yml` was
      written before the decision and is left in place unrun (GitHub Actions is
      additionally billing-blocked on this account — every job fails in ~3 s);
      it is not part of the build path and must not be revived as one. The
      build-time guard it carried is not lost: the same `smoke-test.sh` runs
      inside RunPod's builder from the Dockerfile itself.
- [x] **C.01.05** Keep the GHCR package private. The user creates a fine-grained
      GitHub personal access token (read-packages only, expiry ≤ 90 days) and
      adds it to `env-master.env` as `GHCR_PULL_TOKEN` — not locally actionable
      by an agent; verify by length only. Then
      `runpod-provision.mjs registry-auth create --yes` (C.02.04) registers it
      on RunPod as a Container Registry Auth and records the auth id in the
      evidence file; the endpoint (C.03.01) references that id. Token rotation
      is a documented two-step (new token → update auth → old token revoked) in
      the C.01.02 README.
- [x] **C.01.06** Image smoke test inside CI (same workflow, after build): start
      the container with `--entrypoint` overridden to run ComfyUI's
      `--quick-test-for-ci`/object-info dump, assert the node classes
      `UNETLoader`, `CLIPLoader`, `VAELoader`, `EmptySD3LatentImage`,
      `KSampler`, `RMBG`-family and `SAM3` classes exist. Fail the workflow if
      any is missing. Store the object-info JSON as a CI artifact.
- [x] **C.01.07** Update `infra/runpod/endpoints/image-build-config.json` and
      `image-build-manifest.json` with the slim image entry and mark the old
      `oshunai/runpod-comfyui:*` flavors as `status: "retired-never-published"`
      (do not delete their inventory files; ADR in C.01.08 explains).
- [x] **C.01.08** Write
      `docs/domains/isis/adr/ADR-0005-slim-worker-image-and-volume-models.md`:
      decision (stock worker + node packs only, models on volume, GHCR public
      package), rejected alternatives (baked flavors, Docker Hub, RunPod
      GitHub-integration build), consequences (custom nodes need rebuild; cold
      start loads from volume; cost per cold start).
- [x] **C.01.09** ~~Trigger the CI build, wait for green, record image digest in
      the evidence file.~~ **SUPERSEDED 2026-09-11 (user decision): no GHCR CI
      build exists to trigger.** The equivalent — a green build of this exact
      Dockerfile — is delivered by RunPod's git integration and recorded in the
      evidence file: build `d677f914-d4eb-4a6a-891f-86c94f9f0b24` COMPLETED from
      commit `105ad3cf`, release `cmtxbtcjo00hz1pmmka2539tw` created
      2026-09-11T19:05:26Z. RunPod's build/release API exposes no image digest
      for git-integration builds (verified against `/v2/serverless/<id>/builds`
      and `/releases`), so the commit SHA is the reproducibility handle here,
      not a digest; the image reference RunPod assigns follows
      `registry.runpod.net/greychimp-oshun-runpod-comfyui-slim-docker-runpod-comfyui-slim-dockerfile:<commit8>`.

## C.02 Network volume and on-demand model inventory

- [x] **C.02.01** Write `infra/runpod/volumes/isis-chroma-models.manifest.json`
      (schemaVersion 1): one row per artifact with `id`, `source`
      (`hf`/`civitai`), `repo`/`modelVersionId`, `file`, `sha256` (fill after
      first download; empty string before), `sizeBytes`, `destPath` under
      `/runpod-volume/models/…`, `license`, `quantization: "none"`, `sharedBy`
      (e.g. T5 shared by all three Chroma checkpoints). Rows: chroma1-hd
      (`diffusion_models/chroma1-hd.safetensors`), uncanny-v13-bf16,
      photonic-fusion-debloated-bf16, t5xxl-fp16 (`text_encoders/`), flux-ae
      (`vae/`), sam3 (folder per C.01.03), birefnet-portrait, birefnet-matting,
      birefnet-hr-matting, rmbg-2.0.
- [x] **C.02.02** Add `scripts/isis/runpod-volume-manifest-lint.mjs` + vitest
      spec: every row has a dest under an allowed ComfyUI folder, no duplicate
      dest, no quantized filename patterns (`gguf`, `fp8`, `int8`, `df11`,
      `nf4`), total size computed and compared to the volume size with ≥ 20 %
      headroom, CivitAI rows carry a `modelVersionId`, HF rows carry a
      `revision` (commit SHA) — not `main`.
- [x] **C.02.03** Write `scripts/isis/runpod-volume-loader.py` — runs INSIDE a
      loader pod: reads the manifest, downloads each row with `hf download`
      (`--revision`) or `curl` with `Authorization: Bearer $CIVITAI_API_KEY`
      (header, never in the URL), verifies sha256 when present, records computed
      sha256 into `/runpod-volume/.oshun/manifest-result.json`, is idempotent
      (skips rows whose sha256 already matches), and never writes outside
      `/runpod-volume`.
- [x] **C.02.04** Write `scripts/isis/runpod-provision.mjs` with subcommands
      `volume create`, `pod create-loader`, `pod delete`,
      `endpoint create|     update|delete`, `endpoint get`, all through
      `https://rest.runpod.io/v1` with `RUNPOD_API_KEY` from the environment;
      `--dry-run` prints the exact request body; every mutating call requires
      `--yes`. Unit spec with a mocked fetch: request bodies match
      `desired-state.json`, `--dry-run` performs zero network calls, missing key
      fails loud.
- [x] **C.02.05** Create the network volume: 100 GB in a datacenter with RTX
      4090 and L40S serverless stock (choose via the REST GPU availability
      query, record the choice). Record volume id + datacenter in the evidence
      file and in `infra/runpod/volumes/desired-state.json` (new).
- [x] **C.02.06** Create the loader pod attached to the volume (cheapest
      CPU/small-GPU SKU in that datacenter), inject `CIVITAI_API_KEY` as a pod
      env var from the local env file, run the loader script, tail until
      `manifest-result.json` reports every row OK. Record wall clock and pod
      cost in the evidence file.
- [x] **C.02.07** Fill the `sha256` column of the manifest from
      `manifest-result.json`; re-run the lint; commit. From here on a mismatch
      is a failure, not a warning.
- [x] **C.02.08** Delete the loader pod; verify via `pod get` that it is gone
      and that `myself.currentSpendPerHr` is 0. Record in evidence. **A loader
      pod left running is the single biggest cost risk in this plan.**
- [x] **C.02.09** Optional, only if the loader path is slower than expected:
      implement `scripts/isis/runpod-volume-s3-put.mjs` using
      `RUNPOD_S3_ACCESS_KEY`/`RUNPOD_S3_SECRET_KEY` against the volume's S3
      endpoint for uploading files that were downloaded elsewhere. Not needed
      for the MVP; keep `[ ]` unless used. _**Used 2026-09-13, so it closes.**
      The script exists since V.05.03 (SigV4 cross-checked against botocore) and
      today it did exactly what this item describes: `RealESRGAN_x4plus.pth` (67
      040 989 B, sha256 `4fa0d389…` matching the Hugging Face LFS oid) was
      downloaded on the Mac and `put` to `models/upscale_models/` in one
      request, the post-PUT `HEAD` verified 67 040 989 bytes, and
      `ls models/upscale_models/` lists it. No loader pod, no GPU, $0 — the path
      to use for anything under a few GB. The loader's
      `.oshun/manifest-result.json` was not rewritten (the C.12.04 inventory
      card lists the volume live, so the new row reads present without it)._
      _**Defect found 2026-09-13 in the multipart path, recorded here because
      this is the script's item:** the 112 MB Lenovo LoRA went over the 100 MiB
      threshold, every part uploaded, and RunPod's volume S3 API answered the
      completion with `400 InvalidPart: part 1 ETag mismatch` — twice. A single
      PUT of the same bytes succeeded (as had a 67 MB one), so the default
      threshold is now 4 GiB (RunPod's single-PUT ceiling is 5 GB) and files
      that size go through the loader pod, which pulled 8.6 GB of LTX weights in
      two minutes for about a cent. The multipart code is proved only against
      the spec's fake S3; making it work against the real API is a separate
      investigation (part ETag format or a required Content-MD5), not assumed._

## C.03 Serverless endpoint provisioning (bounded by design)

- [x] **C.03.01** Add a `comfyui-chroma` entry to
      `infra/runpod/endpoints/desired-state.json` under a new `development`
      environment: `name: isis-comfyui-chroma`, image
      `ghcr.io/greychimp/oshun/runpod-comfyui-slim@<digest>`,
      `gpuIds:     "NVIDIA GeForce RTX 4090,NVIDIA L40S"` (4090 first),
      `workersMin: 0`, `workersMax: 1`, `idleTimeout: 10`,
      `executionTimeout: 300`, FlashBoot on, `networkVolumeId` from C.02.05,
      `endpointIdEnv:     RUNPOD_COMFYUI_ENDPOINT_ID`, env
      `COMFY_POLLING_MAX_RETRIES=1500`, `COMFY_POLLING_INTERVAL_MS=250`. Extend
      the JSON schema/validator that reads this file (find it via
      `grep -rn desired-state.json scripts libs`) so `networkVolumeId`,
      `flashBoot`, `imageDigest` are typed and validated; spec covers the new
      fields.
- [x] **C.03.02** Add `infra/runpod/endpoints/inventory/comfyui-chroma.json`
      (schemaVersion 2): `handlerKind: "worker-comfyui"`,
      `modelFlavor:     "none-volume-backed"`, `workflowIds` = the C.08 ids,
      `requiredModels` = the manifest ids, `requiredCustomNodeClasses` = the
      RMBG/SAM 3 classes, `bakedModelArtifacts: []`. Extend whatever
      generator/validator owns the inventory schema so an empty baked list with
      a volume-backed flavor is valid and asserted in a spec.
- [x] **C.03.03** Add a `warm-cold-policy.json` workload class
      `interactive-image-single` with profile `cold` =
      `{workersMin:0,     workersMaxBase:1, idleTimeout:10}` and make the Chroma
      endpoint reference it. Spec: the policy resolver returns max 1 for this
      class in every profile.
- [x] **C.03.04** Create the endpoint with
      `runpod-provision.mjs endpoint create     --yes`; then `endpoint get` and
      assert the live object matches desired-state (`workersMax === 1` etc.) in
      a small `scripts/isis/runpod-endpoint-drift-check.mjs` (exit 1 on drift).
      Record endpoint id in the evidence file and in the env recipe.
- [x] **C.03.05** Health probe: `GET /v2/<endpoint>/health` returns workers idle
      0 / ready 0 / running 0 and jobs 0 at rest. Record.
- [x] **C.03.06** Kill switch:
      `runpod-provision.mjs endpoint update --workers-max     0 --yes`
      documented and tested against the mocked API; the RunPod page (C.09.05)
      exposes it behind a confirm dialog.
- [x] **C.03.07** Document GPU fallback: if a 1024×1024 Chroma render OOMs on
      the 4090 in C.11.01, switch `gpuIds` to L40S first, re-run drift check,
      note the cost-rate change in the env recipe. Leave `[ ]` unless exercised.

## C.04 Cost control (must be green before the first dashboard job)

- [x] **C.04.01** ~~Set the RunPod account spend limit to a value the user names
      (today it is $80).~~ **CANNOT BE DONE — the premise is wrong (verified in
      the console and the API, 2026-09-11).** RunPod's "Spend rate limit" is a
      platform-imposed ceiling, not a user budget. Its own tooltip: "The amount
      of credits you are allowed to spend per hour. You may request an increase
      when nearing your limit." There is no input for it on `/user/billing` or
      `/user/settings` (the only inputs on those pages are a credit-code box and
      search), and no GraphQL mutation (introspection is disabled; no REST
      route). It can be raised by request, never lowered to a chosen figure —
      the user asked for $5/h and RunPod offers no such control. What actually
      bounds spend, all already in place: **balance $13.97 with Auto-Pay
      disabled** (the real hard ceiling — nothing can bill past it),
      `workersMax: 1` + 300 s execution timeout (~$1.10–1.75/h while a job
      runs), and the API-side daily USD ledger that fails closed. The one
      related knob that IS the user's is the low-balance notification threshold
      ($5.00 today, `/user/settings`).
- [x] **C.04.02** Configure the existing guardrail
      (`runpod-budget-guardrail.ts`) for the dev stack: enabled, soft limit
      $10/month, hard limit $25/month, throttle 3 units per 10 min window,
      `failClosed: true`. Read the middleware in full; confirm it is mounted on
      job submit/batch/retry routes; add a spec that a request over the hard
      limit is rejected with the documented status and reason
      `hard_limit_exceeded`.
- [x] **C.04.03** Implement a **daily** USD ledger in the generation API:
      `apps/isis/generation-api/src/services/runpod-cost-ledger.service.ts`
      persisted in Redis (`isis:runpod:cost:<YYYY-MM-DD>`), fed by the provider
      result's `executionTime`+`delayTime` (ms) × per-second rate from
      `ISIS_COST_RATE_RUNPOD_USD_PER_SECOND` (already read by
      `comfyui.service.ts`; set to the 4090 or L40S rate that matches `gpuIds`).
      A submit is refused with 429 + `Retry-After` when the ledger plus the
      workflow's `estimated_cost_usd` (C.08 catalog field) exceeds
      `ISIS_RUNPOD_DAILY_BUDGET_USD` (default 3.00). Fail closed if Redis is
      unreachable. Specs: exact arithmetic, day rollover in UTC, refusal
      boundary, Redis-down path.
- [x] **C.04.04** Verify the RunPod adapter actually surfaces
      `executionTime`/`delayTime` from `/status` into `RunComfyJobResult` (read
      the adapter's status mapping; add the fields if absent) and that
      `comfyui.service.ts` `transformResult` passes them through to the job
      record. Spec on both.
- [x] **C.04.05** Expose `GET /api/runpod/cost/today` (ledger total, job count,
      budget, remaining, per-workflow breakdown) on the generation API; extend
      `libs/isis/client/src/resources/*` and the OpenAPI document
      (`pnpm openapi:generate`, semantic diff reviewed). Spec at route and
      client level.
- [x] **C.04.06** Alarm: when the ledger crosses 80 % of the daily budget, emit
      a structured log event and a webhook via the existing
      `webhook-subscription.service.ts` (`runpod.budget.warning`); at 100 % emit
      `runpod.budget.exhausted`. Spec with a fake subscriber.
- [x] **C.04.07** Per-job cap: reject any catalog workflow whose rendered graph
      has `steps > 60`, `batch_size > 4`, or `width*height > 2048*2048` for
      Chroma; enforce in the executor before submit (fail loud with the field
      name). Spec.
- [x] **C.04.08** Execution-time cap coherence: executor `timeoutMs` for Chroma
      workflows ≤ endpoint `executionTimeout` (300 s) — the API must never wait
      longer than RunPod will bill. Spec asserts the relation using the
      desired-state file as fixture.

## C.05 RunPod adapter: stock worker contract

- [x] **C.05.01** Extend `RunPodJobOutput.images[]` in `runpod-adapter.ts` to
      `{ filename?, nodeId?, url? } | { filename, type: 'base64'|'s3_url',     data }`
      and make `mapRunPodOutput` produce `JobOutput` entries with either `url`
      (s3_url / legacy) or `dataBase64` + `mimeType` (base64; sniff
      PNG/JPEG/WebP magic bytes, fail loud on unknown). Also map the stock
      worker's `output.errors[]` into a non-fatal `warnings` array on the
      result. Specs: legacy shape, s3_url shape, base64 PNG, base64 with bad
      magic → error, errors array preserved.
- [x] **C.05.02** Make `translateToRunPodFormat` emit the stock worker's input
      images when the request carries image inputs:
      `input.images = [{ name,     image: 'data:<mime>;base64,…' }]`, and
      rewrite `LoadImage.inputs.image` references in the graph to those names.
      Keep the legacy `inputs`/ `workflowMetadata` keys (harmless to the stock
      worker). Spec.
- [x] **C.05.03** Status polling: confirm `/status/<id>` mapping handles
      `IN_QUEUE`, `IN_PROGRESS`, `COMPLETED`, `FAILED`, `CANCELLED`, `TIMED_OUT`
      and that a `FAILED` job surfaces the worker's `error` string verbatim. Add
      `POST /cancel/<id>` support if absent (needed by C.09.06). Spec.
- [x] **C.05.04** Cold-start visibility: surface `delayTime` as
      `queueAndColdStartMs` on the result and log a `runpod.cold_start` event
      when it exceeds 20 s. Spec.
- [x] **C.05.05** Adversarial pass on the adapter changes (grep + silent-stub
      scan per the tracker rules); record the short evidence block.

## C.06 Executor: API-side catalog rendering behind a worker-kind flag

- [x] **C.06.01** Add `ISIS_RUNPOD_WORKER_KIND` (`oshun-handler` default |
      `worker-comfyui`) to `libs/shared/config/src/features.ts` with a typed
      getter and validation; document in the config README. Spec.
- [x] **C.06.02** In `executor.ts`, when the worker kind is `worker-comfyui`:
      load the catalog JSON (`WORKFLOWS_DIR/<category>/<id>.json`), render it
      with `renderCatalogWorkflow` from `@isis/workflows` using the job's
      `workflowInputs` (seed normalisation via `normalizeSeedValue`, aspect map,
      prompt construction), strip non-API keys (`outputs`, `_comment`), and
      submit the bare graph as `workflow` instead of `workflow.id`. Keep the id
      in `metadata.workflowId`. Spec: rendered graph for `chroma-txt2img`
      matches a golden fixture byte-for-byte for a fixed seed; `oshun-handler`
      path unchanged (existing specs still green).
- [x] **C.06.03** Pre-submit validation: every `class_type` in the rendered
      graph must appear in the endpoint inventory's node class set
      (`comfyui-chroma.json` from C.03.02 + core ComfyUI class list captured by
      C.01.06's object-info artifact, checked into
      `infra/runpod/endpoints/node-classes/worker-comfyui-5.1.0.json`); every
      `models_required` id must exist in the volume manifest. Fail loud with the
      missing name. Spec.
- [x] **C.06.04** `comfyui.service.ts` `translateRequest`: accept a graph object
      without wrapping it as `{ id }`; keep string ids working. Spec.
- [x] **C.06.05** Adversarial pass on executor/service changes; evidence block.
- [x] **C.06.06** _(found 2026-09-11)_ Nothing in the repository consumes the
      `isis:jobs:submit` queue and runs `WorkflowExecutor` (the gpu-worker app
      executes Blender/3DGS/mesh/texture work only), so a submitted job would
      never run. Add an in-process runner to the generation API behind
      `ISIS_INLINE_JOB_RUNNER=true`
      (`apps/isis/generation-api/src/services/inline-job-runner.service.ts`):
      claim the oldest pending/queued job (status → running, workerId), execute
      it through `getWorkflowExecutor().execute` streaming progress into
      `JobService.updateProgress`, then `setOutput` / `setError`; one job at a
      time; SIGTERM drains the in-flight job. Specs: claim order, progress
      clamping, failure and exception paths, cancelled-between-list-and-claim
      skip, start/stop drain.

## C.07 Output persistence and retrieval

- [x] **C.07.01** Decide and implement the store for base64 outputs: MinIO from
      `docker/docker-compose.dev.yml` (bucket `isis-outputs`) via the S3 client
      already used in `apps/isis/gpu-worker` (`@aws-sdk/client-s3`), keyed
      `jobs/<jobId>/<index>.<ext>`; fall back to `ISIS_OUTPUT_DIR` on local disk
      when `ISIS_OUTPUT_S3_ENDPOINT` is unset. Both paths return a URL the web
      app can render (presigned or `/api/outputs/<jobId>/<index>` streamed by
      the API). Specs on both backends with a fake S3.
- [x] **C.07.02** Persist `width`, `height`, `mimeType`, `sha256`, `seed`,
      `workflowId`, `checkpoint`, `costUsd`, `executionMs`, `delayMs` alongside
      each output so the Outputs page can show them. Spec.
- [x] **C.07.03** Extend `libs/isis/client/src/resources/outputs.ts` and the
      OpenAPI document for the new fields; semantic diff reviewed; parity specs
      updated (`outputs.projection.spec.ts`).

## C.08 Chroma workflow catalog (`libs/isis/workflows/src/workflows/chroma/`)

Each workflow JSON follows the existing catalog shape, declares
`custom_nodes_required`, `models_required`, `estimated_time_seconds`,
`gpu_requirement`, and a new `estimated_cost_usd` (C.04.03 reads it). Sampler
defaults come from the ComfyUI Chroma reference workflow and are then adjusted
against a real render in C.11 — the value that ships is the one that rendered.
Register each id in `utils/registry.ts`, pass all three `utils/*-lint.ts` lints,
add a `workflows.spec.ts` case, and add the id to the job-envelope routing
manifest (`libs/isis/job-envelope/src/job-envelope.ts`) for its generation type.

- [x] **C.08.01** `chroma-txt2img`: inputs `prompt`, `negative_prompt`,
      `checkpoint` enum {`chroma1-hd`, `uncanny-v13-bf16`,
      `photonic-fusion-debloated-bf16`} mapped to the manifest filenames,
      `aspect` map (square*1024, portrait_896x1152, landscape_1152x896,
      portrait_832x1216, landscape_1216x832), `steps` (default per reference,
      max 60), `cfg`, `sampler`, `scheduler`, `seed`, `batch_size` (≤ 4). Graph:
      `UNETLoader` → `CLIPLoader(type=chroma)` → two `CLIPTextEncode` →
      `EmptySD3LatentImage` → `KSampler` → `VAEDecode` → `SaveImage`. Golden
      fixture for the rendered graph. \_Deviation 2026-09-11: `sampler` shipped
      (enum wired to `KSamplerSelect.sampler_name`, options taken from
      `sampler_name` values already shipped elsewhere in this catalog).
      **`scheduler` deliberately NOT shipped** — swapping scheduler families
      means swapping node class (BetaSamplingScheduler `alpha`/`beta` vs
      BasicScheduler `scheduler`/`denoise`), and the catalog's `_condition`
      mechanism bypasses a node through its own input rather than choosing
      between two classes, so an either/or would wire a type-wrong link into
      `sigmas`. The Chroma reference schedule beta(0.45/0.45) stays fixed, with
      the reason recorded on node 10. Golden:
      `src/workflows/chroma/__golden__/chroma-txt2img.square_1024.golden.json` +
      `src/chroma-txt2img-golden.spec.ts` (10 cases).*
- [x] **C.08.02** `chroma-img2img`: as above plus `LoadImage` + `VAEEncode` and
      `denoise` input; image arrives via C.05.02's base64 path.
- [x] **C.08.03** `chroma-inpaint`: `LoadImage` (image + mask) →
      `VAEEncodeForInpaint` / `SetLatentNoiseMask` → sampler; inputs
      `grow_mask_by`, `denoise`.
- [x] **C.08.04** `matting-remove-background`: input image + `model` enum
      {`rmbg-2.0`, `birefnet-portrait`, `birefnet-matting`,
      `birefnet-hr-matting`} → ComfyUI-RMBG node(s) → `SaveImage` RGBA plus a
      separate mask PNG output. ~~`output_spec.type: "image+mask"` — extend the
      output-contract lint if needed.~~ _Deviation 2026-09-11: no lint extension
      and no new type string. The schema already expresses this as
      `output_spec.render_passes` (`beauty` + `mask`), which the executor
      populates and the client surfaces as `JobOutput.renderPasses`; inventing
      `"image+mask"` would have bypassed all of that. Doing it this way exposed
      a real defect — the executor infers a pass from the SaveImage FILENAME and
      tests `mask|matte|alpha` before `beauty|rgba|color`, so the old
      `isis/matte-cutout` prefix classified the cut-out as the mask. Prefixes
      renamed (`isis/removebg-rgba` / `isis/removebg-mask`) and pinned by
      `src/chroma-render-pass-contract.spec.ts`._
- [x] **C.08.05** `sam3-segment`: input image + `text_prompt` (+ optional
      point/box) → SAM 3 nodes → mask PNG + overlay preview. Both outputs saved.
- [x] **C.08.06** `sam3-segment-inpaint`: composition of C.08.05 and C.08.03 in
      one graph (segment by text, optionally grow, inpaint with a Chroma
      checkpoint). This is the "complete workflow" the initiative is for.
- [x] **C.08.07** `chroma-txt2img-then-matte`: txt2img → RMBG/BiRefNet cut-out
      in one graph (RGBA output) — the product-ready "generate a subject on
      transparent background" flow.
- [x] **C.08.08** Generation-type routing: add/confirm entries so
      `text-to-image`, `image-to-image`, `inpaint`, `background-removal`,
      `segmentation` route to the Chroma ids when `COMFYUI_PROVIDER=runpod` and
      the worker kind is `worker-comfyui`; existing routes untouched. Spec in
      `executor.spec.ts` for the resolver. _Deviation 2026-09-11:
      **`background-removal` and `segmentation` are not generation types** —
      `ISIS_GENERATION_TYPES` (libs/isis/job-envelope) has no such members, and
      adding them would change a contract shared with the BFF, mobile and the
      job schema, well outside this tracker. Both flows take a source image, so
      they route under `image-to-image`, and the Studio reaches them by explicit
      `parameters.workflowId` regardless. `inpaint` is spelled `inpainting` in
      that enum. **A real misroute was found and fixed:**
      `chroma-txt2img-then-matte` takes a prompt and has no image input, but its
      `matting` tag matched the substring heuristic and offered it under
      `image-to-image` — a job would have been accepted, a worker booted, and
      the graph failed for a missing image after the GPU seconds were billed. An
      explicit generation-type tag now beats the substring heuristics; measured
      against the whole catalog, that changes this one entry and nothing else.
      Spec: `src/workflows/chroma-generation-type-routing.spec.ts` (8 cases,
      including the invariant that every workflow offered for image-to-image or
      inpainting declares an image input). `executor.spec.ts` stays at its
      pre-existing 13 failures._
- [x] **C.08.09** Provider-compatibility metadata: mark each Chroma workflow as
      `runpod-worker-comfyui` only (not RunComfy, not the old handler) so the
      resolver's fallback strategy never sends it elsewhere. Spec. _Shipped as a
      resolver bootstrap gate: the `chroma` category is registered only when
      `COMFYUI_PROVIDER=runpod` and `ISIS_RUNPOD_WORKER_KIND=worker-comfyui`
      (`WORKER_COMFYUI_ONLY_CATEGORIES`, `chroma-catalog-routing.spec.ts`)._
- [x] **C.08.10** Adversarial pass over the catalog folder (no placeholder
      prompts/seeds, no `TODO`, every `models_required` present in the volume
      manifest); evidence block.

## C.09 Dashboard (existing `apps/isis/web`, minimal additions)

- [x] **C.09.01** Workflows page lists the `chroma` category; Workflow Details
      renders the input schema (enum pickers, numeric ranges, image upload with
      client-side base64 + size cap 12 MB). Vitest spec for the form renderer
      with the `chroma-txt2img` schema. _2026-09-11: the catalog had no HTTP
      surface at all (the Workflows page is served by the workflow-registry
      service, which does not know these workflows exist), so
      `GET /api/v1/workflows/catalog` now exposes the already-warmed resolver
      read-only, `client.generation.listCatalogWorkflows` reaches it, and the
      Workflows page lists the chroma category from it — rather than seeding the
      registry with a copy that would drift from the JSON the worker executes.
      The form-renderer core is built and specced against the real
      `chroma-txt2img` schema (`catalog-form-utils.ts`, 19 cases: enum pickers
      with the three checkpoint names, numeric bounds at both ends,
      fractional-step rejection, the 4000-char prompt cap, the inclusive 12 MB
      image cap, and non-image rejection before a byte is read).
      `WorkflowDetailsPage` renders that form too: when the id matches a catalog
      entry it fetches the schema and renders `CatalogInputForm`, every control
      built from the schema (13 further cases — the checkpoint picker
      pre-selects the catalog default rather than showing an empty box, `steps`
      carries min/max/step 1 while `cfg` steps by "any", the bound appears in
      the help text before submitting rather than after, an out-of-range value
      complains and the complaint clears when it returns to range, and the file
      picker's `accept` excludes formats the worker cannot decode). The existing
      81 WorkflowDetailsPage tests stay green._
- [x] **C.09.02** Job Submission Studio: checkpoint picker with the three Chroma
      names and their disk size/notes, aspect preset buttons, seed "random/lock"
      toggle, an **estimated cost** line computed from `estimated_cost_usd` and
      the current cost-rate, and a disabled submit button with the reason when
      `GET /api/runpod/cost/today` says the budget is exhausted. Spec.
- [x] **C.09.03** Jobs page: show status transitions incl. cold-start phase
      (from `queueAndColdStartMs`), live poll ≤ 5 s, `Cancel` action wired to
      C.05.03. Spec.
- [x] **C.09.04** Outputs page: render PNG/RGBA previews (checkerboard for
      alpha), show seed/checkpoint/steps/cost/execution time, download link via
      the API stream. Spec. _Interpretation 2026-09-11: **generated images
      surface on the Jobs page, not the Outputs page.** `OutputsPage` is the
      Outputs *service* (provenance, tags, signed download URLs) — a different
      resource that never holds a generation's RGBA result; the C.09.07
      Playwright run verified the thumbnail and caption on the Jobs page. So the
      checkerboard, facts and download link were built there. Alpha-capable
      thumbnails (PNG/WebP/GIF, not JPEG) sit on a checkerboard: a matting or
      SAM 3 cut-out is fully transparent and otherwise reads as "nothing
      rendered". The download link is the stored URL, which for the local
      backend IS the C.07.01 API stream route. **`steps` is not duplicated into
      the output facts** — it is a job input, visible on the job record, and
      copying it into every output row would create a second place for it to
      drift._
- [x] **C.09.05** RunPod page: today's spend vs daily budget meter, monthly
      soft/hard guardrail state, endpoint health (workers, queue), and the kill
      switch (workers-max → 0) behind a confirm dialog. Reuse
      `@isis/runpod-surface` cost-quota types. Spec.
- [x] **C.09.06** Dev login: document the JWT dev-token mint (a script
      `scripts/isis/mint-dev-jwt.mjs` using `JWT_SECRET`, issuer/audience from
      `app.ts`) and make `LoginPage` accept a pasted token in non-production.
      Spec on the script (claims, expiry).
- [x] **C.09.07** Playwright, chromium only, `workers=1`, against the real dev
      stack with the generation API mocked at the HTTP boundary
      (`E2E_BASE_URL` + route interception): submit `chroma-txt2img`, see the
      job progress, see the output card, see the cost meter move. Spec file
      `apps/isis/web/e2e/chroma-runpod-dashboard.spec.ts`.
- [x] **C.09.08** One real-browser pass (not mocked) after C.11.01 succeeds:
      screenshot the Outputs card of the first real Chroma image into the
      evidence file. Kill the Vite server afterwards (`lsof` check). **Done
      2026-09-12, $0** — job `4bae0703`, completed, thumbnail **decoded by the
      browser at 1024×1024** from its data URL, showing C.11.01's red bicycle.
      Vite killed, `lsof` on 5180 empty. **The "Outputs card" wording is a wrong
      premise:** `/outputs` is served by the separate `@isis/output-registry` on
      :3002 and the generation API never writes to it, so no RunPod render can
      ever appear there. The card is on `/jobs`. Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § C.09.08.

## C.10 Local dev stack recipe

- [x] **C.10.01** `docs/domains/isis/runbooks/chroma-runpod-dev-stack.md`:
      `docker compose -f docker/docker-compose.dev.yml up -d redis minio`, env
      recipe from C.00.03, `pnpm dev` for the generation API (port from `PORT`,
      4010 convention), `VITE_ISIS_GENERATION_API_URL`, Vite 5180, the `lsof`
      teardown line, the "one Next/Vite server per session" rule, and the memory
      checkpoint before Playwright.
- [x] **C.10.02** `scripts/isis/dev-stack-preflight.mjs`: asserts Redis and
      MinIO reachable, endpoint id set, worker kind set, budget vars set, cost
      rate matches the endpoint's `gpuIds` (4090 → 0.000306, L40S → 0.000486;
      table in the script, sourced from the pricing snapshot date), and refuses
      to continue otherwise. Spec.
- [x] **C.10.03** `apps/isis/generation-api` `/health` reports provider `runpod`
      healthy, worker kind, endpoint id (masked), and today's ledger total.
      Spec. _Shipped on `/ready` (authenticated detail, `runpodChroma` block) —
      `/health` is the public liveness verdict and must not disclose ids._

## C.11 Live end-to-end verification (one real image per workflow)

Each item: run from the dashboard (or the API for the mask-only flows), record
job id, RunPod job id, `delayTime`, `executionTime`, USD, cold or warm, GPU
actually assigned, output sha256, and a thumbnail path in the evidence file. A
failure is recorded as a failure with the worker's error text; the item stays
`[ ]`.

- [x] **C.11.01** `chroma-txt2img` with `chroma1-hd`, square*1024, default steps
      — the first real image. Includes the cold start; record both the cold and
      a second warm run. \_Measured 2026-09-11 (RTX PRO 4500 Blackwell, EU-RO-1,
      ledger rate 0.000306 $/s): cold 53.3 s delay + 150.1 s GPU = $0.083; warm
      9.4 s delay + 152.9 s GPU = $0.084. GPU time is dominated by loading T5
      (~40 s) and Chroma1-HD (~65 s) from the volume on every container start;
      sampling 26 steps at 1024² is ~45 s. Evidence file, C.11 table.*
- [x] **C.11.02** `chroma-txt2img` with `uncanny-v13-bf16`. _Measured
      2026-09-11: warm 10.1 s delay + 180.9 s GPU = **$0.0584**, job `5b7af111`,
      worker `bh3ek2iz6grdek`, 1024×1024 RGB PNG sha `9d49c5b4`._
- [x] **C.11.03** `chroma-txt2img` with `photonic-fusion-debloated-bf16`.
      _Measured: 1.1 s delay + 104.4 s GPU = **$0.0323**, job `e54a1b62`, sha
      `f9090659`. Faster than C.11.02 because T5 was already resident — the
      checkpoint swap costs ~17 GB of load, the text encoder does not reload._
- [x] **C.11.04** `chroma-txt2img` batch\*size 2, portrait_896x1152 — confirms
      the per-job caps and the 4090 memory headroom. **Closed 2026-09-12: the
      cap now refuses its own killer, for $0.** Re-submitting the SAME
      combination through the live API returns `batch_size must be <= 1` and
      never reaches a GPU — no dispatch line in the log. Both halves of the
      question are answered: the headroom is not there, and C.12.19's
      resolution-scaled cap enforces that before billing. \_The original run:
      **\*FAILED 2026-09-11, recorded as a failure.** 98.8 s then
      `ComfyUI HTTP unreachable during websocket reconnect` — ComfyUI died
      mid-render. Two 896×1152 latents beside a 17.4 GB checkpoint do not fit 24
      GB. This is the answer the item was asking for: the headroom is not there,
      and the C.04.07 cap of batch*size ≤ 4 is too generous at this resolution.
      Cost $0.0303. Follow-up C.12.19.*
- [x] **C.11.05** `chroma-img2img` from the C.11.01 output. _Measured: 0.1 s
      delay + 218.0 s GPU = **$0.0668**, job `83a6f93b`, sha `abbd2b61`; source
      was the C.11.02 output, denoise 0.6._
- [x] **C.11.06** `chroma-inpaint` with a hand-drawn mask. _Measured: 0.1 s
      delay + 24.9 s GPU = **$0.0077** (warm, Chroma already resident), job
      `a3e4…`, sha `2f55a5c9`; generated circular mask, grow_mask_by 12. The
      mask was generated rather than hand-drawn — recorded as such._
- [x] **C.11.07** `matting-remove-background` × 4 models on the C.11.02 output;
      visually confirm the alpha edge on the hair region for the portrait model.
      _**PARTIAL — stays unchecked.** 3 of 4 models pass: birefnet-portrait,
      birefnet-matting, birefnet-hr-matting each returned a 1024×1024 **RGBA
      cut-out plus a separate RGB mask** ($0.0031/$0.0031/$0.0022). **`rmbg-2.0`
      fails reproducibly** (two attempts, 13.8 s and 15.3 s,
      `Job processing failed`, second on a fresh worker). Not a missing file —
      `models/RMBG/RMBG-2.0/model.safetensors` (884 MB) is on the volume with
      its config. Follow-up C.12.20._ _**CLOSED 2026-09-12: the fourth model
      renders.** Two independent defects had to be fixed first. (1) C.12.20 —
      the graph never sent `process_res`, which only the `RMBG` node class
      requires, so exactly one model of four raised `KeyError`. (2) The image
      endpoint's container disk was 20 GB against an image that outgrew it when
      the video packs landed, so no worker could start at all; the endpoint was
      rebuilt as **`6jye7vngg4i685`** with 30 GB. Measured on the image endpoint
      at the image rate (0.000306 $/s): **delay 76 410 ms (cold) + exec 13 987
      ms = $0.0277**, worker `crr86xi6bdzmxk`, `process_res: 1024` in the
      recorded inputs. **Two real outputs**, matching the two-output contract
      the BiRefNet models produce: `b081ad54…` 1024×1024 **RGBA** 1 651 812 B
      and `96dc6a21…` the RGB mask 21 296 B. The alpha was decoded and checked
      rather than assumed — **19.7 % fully opaque, 3.0 % fully transparent, 77.3
      % soft edge** — so it is a real matte, not a black one; the large
      soft-edge fraction is recorded as measured and not claimed to be good. The
      three BiRefNet rows stand as measured 2026-09-11 on the previous endpoint
      id; the workflow, image and volume are unchanged._
- [x] **C.11.08** `sam3-segment` with a text prompt naming an object present in
      the C.11.01 image; confirm the mask covers it. **Done 2026-09-12** —
      prompt `the red bicycle`, 21.2 s, **$0.0093**. The mask was DECODED, not
      assumed: 1024×1024, 3.9 % white / 96.1 % black, 2 distinct values, and
      rendered it is an unmistakable bicycle silhouette — wheels, frame, saddle,
      handlebars, rear rack. The RGBA cut-out's alpha agrees exactly. Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § C.11.08. _The old blocker
      below was STALE: C.12.18 landed the SAM 3 runtime and the rebuilt image's
      inventory lists `SAM3Segment`. Nothing needed fixing, only running._
      _Previously: **BLOCKED — not a flake.**
      `Node 'SAM3Segment' not found. The custom node may not be installed.`
      `py/AILab_SAM3Segment.py` imports `sam3` at module level; the pack's
      requirements.txt ships SAM 3's support deps but not the `sam3` package,
      and the pack's auto-loader swallows the ImportError. Needs a Dockerfile
      change + rebuild. Follow-up C.12.18._
- [x] **C.11.09** `sam3-segment-inpaint` end to end. **Done 2026-09-12** — 207.2
      s, **$0.0909**. Its mask is BYTE-IDENTICAL to C.11.08's (sha `7ab8f633`, 6
      260 B), which is the determinism you want from the same prompt on the same
      image, and the result shows the red bicycle replaced by a green one with
      wall, pavement, sky and lighting preserved (the wall shadow is still the
      original bicycle's — correct, inpaint repaints only the masked region).
      Evidence: § C.11.08. _Previously **BLOCKED** on the same missing
      `SAM3Segment` node as C.11.08; C.12.18 fixed it._
- [x] **C.11.10** `chroma-txt2img-then-matte` end to end. _Measured: 0.1 s
      delay + 35.1 s GPU = **$0.0108**, sha `c53d031e` (RGB original) +
      `f54fdd9b` (**RGBA cut-out**), proving the two-output contract on live
      output._
- [x] **C.11.11** Budget refusal, for real: set `ISIS_RUNPOD_DAILY_BUDGET_USD`
      below today's ledger, submit, confirm 429 and the dashboard's disabled
      state; restore the value. _Done 2026-09-12 against the live dev stack
      (Postgres + Redis + API 4010 + dashboard 5180, real endpoint id and RunPod
      key configured), **$0 — the gate refuses before anything reaches RunPod**.
      `POST /api/v1/jobs` → **429** `RUNPOD_DAILY_BUDGET_EXCEEDED`,
      `reason: budget_exhausted`, `estimatedCostUsd 0.011`, `retryAfter 43393`
      (UTC midnight), with `x-runpod-daily-budget-usd: 0.25`, `-spend-usd: 0.5`,
      `-remaining-usd: 0`. Nothing was created: the job list stayed at 7 rows,
      all from 2026-09-11, the ledger total did not move, and the API log shows
      no RunPod dispatch. Dashboard in **real chromium**: `studio-submit`
      disabled with the reason rendered verbatim, and the RunPod card showing
      the same numbers; after restoring the budget to $3 the button is enabled
      again and the reason is gone ($2.5000 remaining). Two screenshots in the
      evidence file. **How the exhausted state was reached is stated openly
      there: the spend was SEEDED into a throwaway ledger key**
      (`ISIS_RUNPOD_COST_LEDGER_KEY_PREFIX=isis:drill:c1111:cost`), not earned —
      the real `isis:runpod:cost:2026-09-12` key was verified absent before and
      after, and the drill key was deleted. The dashboard's disabled state needs
      `remainingUsd <= 0`, which a budget merely set below the job's estimate
      does not produce (that is the `estimate_exceeds_remaining` branch), so
      reaching the branch the item names either costs real GPU seconds or takes
      a seeded fixture; the fixture was the honest cheaper one. **A finding on
      the way:** an auth snapshot whose `projectId` does not match the bearer
      token's claim renders as `Ledger unavailable: Project scope mismatch` —
      correct fail-closed behaviour, but visually identical to a Redis outage,
      so check scope before infrastructure when that string appears. Stack torn
      down, `lsof` clean, no chromium orphans, throwaway env script deleted._
- [x] **C.11.12** Kill switch, for real: workers-max → 0, submit, confirm the
      job sits `IN_QUEUE` and is cancelled by C.05.03 within the API timeout;
      restore workers-max 1; drift check green.
- [x] **C.11.13** Rest-state check at session end: endpoint health shows 0
      workers, `currentSpendPerHr` 0, no pods; write the day's total USD from
      RunPod's billing view next to the ledger's total in the evidence file
      (they should agree within cold-start rounding; explain any gap).
- [x] **C.11.14** Update the cost-model table in this file with measured
      numbers; commit.

## C.12 Follow-ups after the MVP (out of today's scope, keep visible)

- [x] **C.12.01** LoRA support for Chroma (volume `models/loras/`, `LoraLoader`
      splice via the existing `LoRAManager` pattern in `flux-workflows.ts`,
      catalog `loras[]` input). _Checked 2026-09-13, stays `[ ]` pending a
      choice only the user can make: WHICH Chroma LoRA ships. The mechanism is
      cheap now — a LoRA file goes to `models/loras/` for $0 through the S3 PUT
      (C.02.09) plus a manifest row, and the C.12.02 pattern (`_condition`-gated
      nodes, here a `LoraLoaderModelOnly` between `UNETLoader` and
      `ModelSamplingAuraFlow`, with `lora` and `strength` inputs) is the splice,
      proved offline by the static validator and the build's ComfyUI validator
      like every other mode. What is missing is not code: no ungated,
      licence-clean Chroma LoRA is on the volume or in the manifest, and
      choosing one from CivitAI (style, licence, commercial terms) is a product
      decision. Blocked on: the user naming a LoRA (repo or CivitAI
      model-version id) and accepting its terms._ _**Built 2026-09-13 after the
      user's pick; live stills pending.** The four LoRAs are on the volume under
      `loras/` (downloaded with the CivitAI key, sha256-verified against
      CivitAI's own hashes, PUT over S3 — 112.1 MB, 28.1 MB, 6.8 MB, 74.8 MB)
      with manifest rows `chroma-lora-*` (strict lint 0/0). `chroma-txt2img` and
      `chroma-img2img` gained `lora` (none | lenovo-ultrareal |
      chroma-realistic-slider | chroma-defluxer | style-muk) and `lora_strength`
      (−2..2); the splice is a `_condition`-gated `LoraLoaderModelOnly` between
      `UNETLoader` and `ModelSamplingAuraFlow` with
      `_condition_passthrough: model`, so with `none` the render is
      byte-identical to the golden (asserted); Lenovo's trigger `l3n0v0` is
      appended to the prompt through `lora_trigger_map`. Golden
      `chroma-txt2img.square_1024.lora-lenovo.golden.json`; golden spec 14/14;
      the chroma inventory lists the models and `LoraLoaderModelOnly`. Owed for
      the box (user decision): one live still per LoRA on the image endpoint
      after build `ea83e467` releases (its shadow volume lists the four files,
      so the snapshot's `lora_name` combo accepts them)._ _**Closed 2026-09-13 —
      all four rendered live on the image endpoint** (worker `1u0p43eprdxnmz`,
      image `47a74b751`), same prompt, checkpoint `chroma1-hd`, seed 1213,
      strength 1.0, only the LoRA varying: Lenovo UltraReal `8d63d12f` (exec
      211.3 s, $0.093, the re-run), Realistic Slider `9ed5aeb4` (139.6 s,
      $0.061), Defluxer `4f2d611f` (28.4 s, $0.012), Style > Muk `fd6106f6`
      (29.9 s, $0.013) — all 1024×1024, execution-only cost at $0.000439/s.
      **The loader really reads the volume:** the first Lenovo attempt ran
      before that file had landed and ComfyUI refused it with
      `value_not_in_list`, listing exactly the LoRA files then on the volume.
      **The LoRA really changes the render:** pairwise mean absolute pixel
      difference between the four is 26.5–44.1 levels, 40–64 % of pixels
      differing by more than 32; Lenovo, whose trigger word is appended, moves
      the composition, the others mostly the grade (contact sheet
      `v12-proofs/lora-contact-sheet.jpg`). **Two honest limits:** (1) the
      catalog input is a single-LoRA enum with a strength, not the `loras[]`
      list the item imagined — stacking is not implemented; (2) Style > Muk is
      an illustration style and at strength 1.0 on a photographic prompt the
      still still reads as a photograph, so it is proved to load and alter the
      output, not to deliver its style. A Lenovo upload also exposed a real
      defect in the volume S3 script's multipart path (C.02.09 note)._
- [x] **C.12.02** Upscale pass (RealESRGAN / SeedVR2) as an optional tail node —
      needs the upscale model on the volume and possibly a node pack rebuild.
      _(Video upscale is covered by V.08.09 FlashVSR; this item stays for still
      images.)_ _**Built 2026-09-13, $0; no node pack needed.** Model:
      `RealESRGAN_x4plus.pth` (Xintao Wang's BSD-3 release, taken from the
      ungated `lllyasviel/Annotators` mirror at `982e7eda…`, 67 040 989 B,
      sha256 `4fa0d389…` verified locally against the HF LFS oid) — manifest row
      `realesrgan-x4plus` at `upscale_models/`, strict lint 0/0, and on the
      volume via the S3 PUT (C.02.09). Tail: three CORE nodes —
      `UpscaleModelLoader` → `ImageUpscaleWithModel` →
      `ImageScaleBy 0.5 lanczos` — on `chroma-txt2img` and `chroma-img2img`,
      behind a new `upscale` input (`none` | `x2`, default `none`) using the
      renderer's `_condition` / `_condition_passthrough` mechanism, so with
      `none` the tail is dropped and SaveImage is repointed at VAEDecode: **the
      default render is byte-identical to the pre-existing golden** (asserted).
      Only 2x is offered, on purpose: the worker returns the PNG inline in the
      job output and a 4x (~16 MP) still would not fit RunPod's job-output
      ceiling until outputs travel by the volume (V.12.05) — the 4x model scaled
      to 2x is a documented approximation, not a hidden one. New golden
      `chroma-txt2img.square_1024.x2.golden.json` (18 nodes); the golden spec
      gained `none` and `x2` cases; the static validator accepts all 19 goldens
      against the real snapshot (`MODEL_NOT_ON_VOLUME` sees the manifest row;
      the snapshot's `UpscaleModelLoader` combo is empty until the next build
      lists the shadow file); `workflows.spec` lints (`model_name` is inferred,
      so `models_required` carries the file) and the API's submission/routing
      specs are green — 154 + 26. The dashboard needs nothing: the Studio form
      is catalog-derived. **Remaining for the box:** the RunPod build that runs
      ComfyUI's own `/prompt` validator over the x2 golden against the shadow
      volume (V.01.09), then the snapshot refresh. Live proof is deliberately
      not added (initiative rule: offline validation stands in for a clip; one
      render, with a reason, if a default looks wrong)._ _**Closed 2026-09-13
      06:13Z.** RunPod build `b60db5b1` (commit `a5118e068`, branch
      `runpod-comfyui-slim`) COMPLETED: the shadow volume had **43** zero-byte
      files (the new row included),
      `77 required classes present, 1071 classes total`, and ComfyUI's own
      validator accepted **19/19** rendered graphs —
      `chroma/chroma-txt2img.square_1024.x2.golden.json nodes=18 http=200` among
      them — with `smoke exit 0`. The object-info snapshot was refreshed from
      that build's log (`runpod-build-snapshot.mjs`, sha256 `aa1ac72b…`); its
      only class-level change is `UpscaleModelLoader.model_name` options going
      from `[]` to `["RealESRGAN_x4plus.pth"]` (plus one VHS extension list
      reordered, set noise), and the snapshot, golden and validator specs pass
      56/56 against it. Both endpoints auto-released `a5118e068`; the runtime
      layers are unchanged, only the validation inputs moved. Excerpt:
      `docs/agents/evidence/isis-chroma-runpod/build-b60db5b1-smoke-validate.txt`._
- [x] **C.12.03** Reference/IP-Adapter or ControlNet for Chroma if a supported
      pack exists at the time; otherwise record "no supported pack" with the
      date rather than approximating. _**No supported pack, checked 2026-09-12**
      — which is the outcome this item defines for the negative case, so it is
      recorded rather than approximated. Method, so the check is repeatable: the
      HuggingFace model API for `chroma controlnet` and `chroma ipadapter`
      returns **nothing**, and of the first 100 repos matching `chroma` not one
      has `control` or `adapter` in its id; the CivitAI API for
      `types=Controlnet&query=chroma` returns **nothing**, and every model it
      lists under `baseModels=Chroma` is a Checkpoint or a LORA. ComfyUI's own
      Chroma1-HD documentation (release dated 2025-11) does not mention
      ControlNet, IP-Adapter or any reference-image adapter, and the model
      card's Q&A says in as many words that there are **no known ControlNet
      adapters for Chroma**. **The Flux tooling does not transfer and must not
      be substituted:** Redux and the XLabs / InstantX / Jasper ControlNets are
      trained against FLUX.1-dev/schnell, and Chroma1-HD is an 8.9B
      architectural pruning of schnell's 12B — pointing a catalog input at a
      Flux ControlNet because the lineage is shared would be exactly the
      approximation this item forbids. Re-check with the two API queries above
      before building anything on this. **A side finding that matters to
      C.12.01:** Chroma **LoRAs** genuinely exist on both hubs
      (`silveroxides/Chroma-LoRAs`, `Omnico/Chroma1_diff_loras`, and 5 LORA
      entries under CivitAI's `baseModels=Chroma`), so that item is not blocked
      for want of a model the way this one is._ _2026-09-14: pose and depth
      control for Chroma output is scoped as E.05.03 — a Z-Image controlled
      composition refined by a Chroma checkpoint in the shared `ae` latent; this
      finding (no Chroma ControlNet or adapter) is unchanged._
- [x] **C.12.04** Fold the volume manifest into `@isis/managed-models` and the
      RunPod page's model inventory so operators see what is on the volume.
      _Done 2026-09-12 — **but the `@isis/managed-models` half was deliberately
      NOT done, and that is the first thing to know.** That library is the
      creator-facing browser over post-intake APPROVED models
      (`ManagedModelSummary`: `creatorAttribution`, `licenseTag`,
      `commercialUseAllowed`, `nsfw`, `recipeId`, `intakedAt`). A volume
      artifact has none of those fields, so folding the manifest in would have
      meant inventing six values per row to satisfy a shape — and the two things
      answer different questions: managed-models is "which approved models may a
      creator pick", the volume inventory is "which files are on the disk the
      workers mount". The item's own purpose clause is what was built. **And
      building it from the manifest alone would have been a fabrication**: the
      manifest is declarative, and on the day it declared 42 artifacts while the
      volume held **10**. So `GET /api/v1/jobs/runpod/volume/models` lists the
      volume over S3 and reports each row as `present`, `absent` or `unknown` —
      three states, where `unknown` never degrades to `absent` (a missing
      credential is not evidence a file is missing) and every observed total is
      `null` rather than `0` when unobserved. Measured live: **10 present, 32
      absent, 70.07 GB held of 358.30 GB declared, 288.23 GB still to pull,
      429.93 GB free of 500 GB** — which quantifies V.02.04 exactly and confirms
      it fits. `volume-model-inventory.ts` (pure) + `.service.ts` (manifest
      read + S3 listing, never throws) + the route + the client method and
      types + a full-width RunPod page card. **The browser pass caught two
      defects unit tests could not:** the companion-bytes line rendered
      `(0.00 GB of it is …)` at the real 0.4 MB, and the six-column table was
      clipped off the card entirely at the grid's 244 px — both fixed and the
      first pinned by a spec. Specs: 12 pure, 4 service (against the real
      checked-in manifest), 6 page. Suites: generation-api `src/services` +
      `src/workflows` **472 passed** with the same 11 pre-existing
      `executor.spec.ts` failures; `RunPodPage.spec.tsx` 31 passed; client 352
      passed with **1 failure verified pre-existing at HEAD**
      (`GET     /api/v1/workflows/catalog` missing from the generation contract,
      not mine). OpenAPI regenerated — semantic diff is **two paths added, none
      removed, no schema changes**: mine, and `/api/v1/jobs/chain`, which had
      drifted out of the document before this session; `--check` now clean.
      Evidence file `## C.12.04`, with a landmine recorded: killing the
      `pnpm dev` parent does not kill the tsx child, and a stale API on 4010
      answers every request `401 Invalid token signature`._
- [ ] **C.12.05** Retire `docker/runpod/comfyui/` flavor images formally (delete
      or archive) once nothing references them — needs a caller scan over
      `scripts/isis/*runpod*` and `infra/runpod/**`. _**The caller scan is done
      (2026-09-12) and it says the precondition is NOT met, so the box stays
      `[ ]`.** Things still reference it, and one of them writes to it:
      `generate_runpod_endpoint_image_manifests.mjs` **syncs INTO this
      directory** (`workflow_catalog`, `isis_nodes`) and is a CI gate over
      node/model consistency; **13 of the 17 endpoints** in the generated
      `image-build-manifest.json` build from this context;
      `.github/workflows/deploy-runpod.yml` carries a path filter (~line 97) and
      a buildx job for it (~305–306); `tests/test_catalog_renderer.py` lives
      inside it; and `DEPENDENCIES.md`,
      `V1/features/external-models-and-execution.md` and `ISIS_TODOS_2.md` name
      it in prose. About forty `generate-v2-*` / `validate-v2-*` scripts read
      the manifest itself, so it cannot quietly lose 13 endpoints either.
      Deleting the directory today would break a CI gate and a deploy workflow.
      **A second finding worth the scan:** every image here is tagged
      `oshunai/runpod-comfyui:<flavor>`, a namespace that 404s and will never
      exist (no Docker Hub account, user decision 2026-09-11) — so
      `deploy-runpod.yml`'s comfyui job cannot succeed as written, independently
      of this initiative. Landed instead: `docker/runpod/comfyui/RETIRED.md`,
      which states the retirement, carries the scan table above, and gives the
      five-step order a removal has to happen in (config → regenerate + re-check
      consumers → deploy workflow → `catalog_renderer.py` and its test →
      delete). The file is safe from the generator's `rm -rf`, which only
      targets the two synced subdirectories. Checking this box needs those five
      steps, which are a shared-CI change well outside this initiative's blast
      radius._ _2026-09-18, split into the five steps
      `docker/runpod/comfyui/RETIRED.md` records, so each can be done and
      checked on its own. The parent closes when the fifth does; the steps are
      in dependency order._
  - [ ] **C.12.05.a** Decide the 13 flavor endpoints in
        `infra/runpod/endpoints/image-build-config.json`: mark each
        `status: "retired-never-published"` the way `comfyui-vace`,
        `comfyui-ltx2` and `comfyui-flagship-video` already are under
        `infra/runpod/endpoints/inventory/`, unless a live endpoint in
        `infra/runpod/endpoints/desired-state.json` still names it (then say
        which, and stop). **Verify:** a table in the evidence file with one row
        per flavor and its decision; no flavor is left undecided.
  - [ ] **C.12.05.b** Regenerate
        `infra/runpod/endpoints/image-build-manifest.json` with
        `scripts/isis/generate_runpod_endpoint_image_manifests.mjs`, run
        `validate_runpod_endpoint_image_manifests.mjs`, and run every
        `scripts/isis/generate-v2-*` and `validate-v2-*` script that reads the
        manifest (about forty; list them with
        `grep -l image-build-manifest     scripts/isis/*`). **Verify:** each
        script's exit code is recorded; a consumer that fails against the
        smaller manifest is fixed or named as the reason this step stays open.
  - [ ] **C.12.05.c** Remove the comfyui buildx job and its path filter from
        `.github/workflows/deploy-runpod.yml` (near lines 97 and 305).
        **Verify:** `actionlint` (or `yamllint` if it is not installed) passes
        on the file, and no job in it names `docker/runpod/comfyui` any more.
  - [ ] **C.12.05.d** Settle `docker/runpod/comfyui/catalog_renderer.py` and
        `tests/test_catalog_renderer.py`: the live path uses the TypeScript port
        `libs/isis/workflows/src/templates/catalog-renderer.ts`, so delete the
        Python original after confirming the port's spec covers every case the
        Python test has (list any it does not and port them first). **Verify:**
        a case-by-case table; the port's spec passes.
  - [ ] **C.12.05.e** Delete `docker/runpod/comfyui/`, make the generator stop
        syncing `workflow_catalog` and `isis_nodes` into it, and fix the prose
        references in `DEPENDENCIES.md`,
        `V1/features/external-models-and-execution.md` and `ISIS_TODOS_2.md`.
        **Verify:** `grep -rn "docker/runpod/comfyui/"` over the repository
        returns only `comfyui-slim` paths and history notes; the manifest
        generator and validator pass.
- [ ] **C.12.06** Production hardening: webhook completion instead of polling,
      S3 output upload directly from the worker (`BUCKET_ENDPOINT_URL`) to skip
      base64 transfer. _**Checked 2026-09-13, stays `[ ]`: half of it exists and
      the other half cannot work as designed.** The webhook half exists —
      `POST /webhooks/runpod` (`routes/provider-callbacks.ts`) verifies an HMAC
      signature under `RUNPOD_WEBHOOK_SECRET` and completes, fails or cancels
      the job; the adapter's `webhookUrl` is `undefined` only because an API on
      127.0.0.1 has no URL RunPod can reach, so the dev stack polls. The
      direct-S3 half is blocked inside the stock worker: `worker-comfyui` 5.10.0
      calls `rp_upload.upload_image(job_id, path)` with no bucket name, and the
      SDK it pins (`runpod~=1.7.12`) then uses `time.strftime("%m-%y")` as the
      BUCKET and `<jobId>/<name>` as the key. RunPod's volume S3 API has exactly
      one bucket, the volume id, so that upload can only fail — and on an upload
      failure the worker records an error and returns NO data for the output
      (there is no base64 fallback on that branch). Setting
      `BUCKET_ENDPOINT_URL` today would therefore lose every render. The fix is
      worker-side (a bucket-aware uploader in our image), not an env value._

--- _**Uploader half built 2026-09-13 (user decision: Hetzner Object Storage,
bucket `app-dev-server`, prefix `isis/outputs/`).**
`docker/runpod/comfyui-slim/oshun_uploader.py` is copied into the venv's
site-packages, so every interpreter start replaces `rp_upload.upload_image` when
`BUCKET_ENDPOINT_URL` is set: key `<prefix>/<jobId>/<8 hex><ext>`, real content
type, SigV4 in `BUCKET_REGION` (default the host's first label, `hel1`),
path-style, presigned GET returned — the handler's `s3_url` contract unchanged;
without the env it is a no-op and the build asserts that, and the smoke test
proves the patch and the key layout with a fake env. API side: every `s3_url`
output now carries `requiresSigning` (a presigned URL expires; the watermark
stage needs bytes) and `getVolumeObjectFetcher` accepts presigned https URLs
from `ISIS_WORKER_OUTPUT_FETCH_HOSTS` beside SigV4 volume URLs, refusing
anything else with the reason on the output (`classifyWorkerOutputUrl`, 5 spec
cases). `desired-state.json` declares the six bucket env names and
`COMFY_LOG_LEVEL=INFO` on both endpoints; runbook §5b has the console table.
Owed: the console env on both endpoints (agent pastes, user's choice) and one
live render; the webhook half stays as recorded._

_**Output leg live 2026-09-13 15:51Z.** Two RunPod secrets were created through
GraphQL `secretCreate` with the key values read in-process from env-master (only
lengths checked): `oshun-hetzner-s3-access-key` and
`oshun-hetzner-s3-secret-key`. Both endpoints' console env now holds the polling
values, `COMFY_LOG_LEVEL=INFO`, the bucket endpoint, name, prefix and region as
plain values, and the two keys as secret references, never as values; the image
endpoint showed "Successfully updated endpoint". A model-free 64x64 render on
the image endpoint (job `fa92a327`, worker `sn3ep2gn3t287c`, delay 52.1 s,
execution 3.6 s) returned `s3_url` output at
`hel1.your-objectstorage.com/app-dev-server/isis/outputs/<jobId>/8dbfcf61.png`;
the object is 153 bytes with a PNG signature and a 64x64 header. Still open: the
API-side fetch of such an output (L.06.04's renders go through the API) and the
webhook half, which needs a URL RunPod can reach._

# Video extension (V.00–V.12) — Wan 2.2 / VACE / Animate / LTX-2.3 / SAM 3 / BiRefNet / GIMM-VFI / FlashVSR

Added 2026-09-11 from the user's final video stack. Same rules as C.xx: models
on the (grown) volume, no baking, no quantization, stock worker contract, cost
bounded by configuration, one real clip per workflow before its box is checked.
Every V-item that produces a live artifact cites a row in
`docs/agents/isis-chroma-runpod-evidence.md` under a new `## V.xx` heading.

The video extension is done when a person can open the Isis dashboard, pick a
`motion` workflow, upload a still (or a driving/source video), set the controls
described in V.08, watch the job run through cold start and execution, play the
resulting mp4 (with audio for LTX-2.3, with alpha for the matte flow) in
Outputs, and read its real dollar cost — and when the eight-clip V.11 proof
matrix has run (each clip at the smallest legal size, submitted back-to-back so
the worker stays warm) with costs taken from RunPod's
`executionTime`/`delayTime`. Workflows and modes outside the matrix ship as
`proof_level: "validated"` (never rendered) and say so in the dashboard; nothing
in this file counts a sticker estimate or an unrendered graph as a result.

- [x] **C.12.12** ~~Slim worker image fails at container create on RunPod.~~
      **RESOLVED 2026-09-11 21:39Z — and the image was never the culprit.** The
      git-built slim image (release `d677f914`, commit `105ad3cf`) creates
      containers, boots ComfyUI and returns a real PNG: probe job
      `2ae689ed-871b-4899-bd50-08eb135210b2-e2`, delayTime 78.888 s,
      executionTime 6.403 s, worker `bh3ek2iz6grdek`, $0.026. What was actually
      broken was the **endpoint**, not the image: `6l1f3tku7z2zoy` had stopped
      placing workers entirely (zero in every state, `jobs.completed` 0 for its
      whole life) after the GraphQL `saveEndpoint` call, and a REST PATCH could
      not revive it. Re-saving the same configuration through the console's own
      **Manage → Edit endpoint → Save Endpoint** form un-wedged it immediately.
      Two earlier diagnoses were wrong and are recorded so they are not
      repeated: "the image fails at container create" (it does not) and "EU-RO-1
      has no capacity" (it placed a worker in ~40 s despite a Low Supply label).
      Consequence: matting and SAM 3 workflows now have a runtime, the
      stock-image interim via template `zxojew9tyo` is no longer needed, and the
      fix for a wedged endpoint is a console re-save, not a rebuild.
- [x] **C.12.18** _(found by C.11.08; fixed and proved 2026-09-12)_
      **`SAM3Segment` never registered.** **The original diagnosis here was
      wrong and is corrected:** there is no `sam3` package to install. The SAM 3
      source is **vendored in the pack** at
      `custom_nodes/ComfyUI-RMBG/models/sam3/`, and `py/AILab_SAM3Segment.py`
      puts it on `sys.path` itself. The missing piece is one leaf of its import
      closure: `sam3.model_builder` -> `sam3.model.sam3_video_inference` ->
      `sam3.model.sam3_video_base` -> `sam3.train.masks_ops`, which does a bare
      `import pycocotools.mask`. `pycocotools` is in neither the pack's
      `requirements.txt` nor ComfyUI's, so it raised `ModuleNotFoundError`,
      `__init__.py`'s auto-discovery caught it with a plain
      `print("Error loading …")`, and the node vanished. Verified by walking the
      module-level import closure of the pinned commit (42 modules; the other 13
      third-party leaves are all present). Landed: `pip install pycocotools`; a
      build layer that performs the node's own
      `from sam3.model_builder import     build_sam3_image_model` so a missing
      dep fails with a traceback instead of as an absent class; **the smoke test
      is fatal again** (the full smoke log is dumped to the build output on
      failure — that is what the `set +e` was working around); and the smoke now
      fails on the pack's own `Error loading <file>: <err>` swallow line,
      against an allowlist holding only `AILab_SegmentV2.py` (the deliberate
      `groundingdino-py` omission). **Build `df19db7a` (2026-09-12) proves the
      diagnosis:** it reached the smoke layer, so both the `pycocotools` install
      and the `from sam3.model_builder import …` layer passed — the import that
      had been failing now resolves. The build then failed on a _different_
      silently-swallowed node the new check caught,
      `AILab_Florence2.py: No module named 'matplotlib'`, which had been failing
      in every image shipped so far; matplotlib is not in the pack's
      requirements either and Florence 2 is not in the Isis catalog, so it joins
      the allowlist with its reason. **Build `05bbde18` (commit `216cdba9ad`,
      01:14:55Z → 01:25:52Z) then COMPLETED, and completing is the proof**: the
      smoke boots ComfyUI, reads `/object_info`, and fails on any absent
      `REQUIRED_CLASSES` entry; `SAM3Segment` is one of them; and the layer is
      now fatal — demonstrated, since `df19db7a` failed at exactly that layer.
      The same class list that was worthless as evidence yesterday is evidence
      today, because the check that reads it can fail the build. `sam3-segment`
      and `sam3-segment-inpaint` have a runtime. **Rendering one is
      C.11.08/C.11.09 and still needs GPU seconds.**
- [x] **C.12.19** _(found by C.11.04, 2026-09-11; fixed 2026-09-12)_ **Per-job
      batch cap now scales with resolution.** `batch_size: 2` at 896×1152 killed
      ComfyUI outright (`HTTP unreachable during websocket reconnect`, 98.8 s,
      $0.0303): two latents that size beside a 17.4 GB checkpoint do not fit 24
      GB. `RenderedGraphCaps` gained `maxBatchPixels` (1024² — the largest frame
      this endpoint has actually rendered, C.11.02/C.11.03) and
      `enforceRenderedGraphCaps` refuses any sampling pass whose
      `width × height × batch_size` exceeds it, naming the frame and the
      computed allowance. `maxBatchSizeForFrame` clamps at 1, so the rule only
      ever lowers batching — a lone frame stays governed by `maxPixels`
      (C.04.07) alone. `chroma-txt2img.json` pins `batch_size` to `max: 1` with
      the reason, since every aspect it offers is ~1 MP and a 2 would be refused
      at all of them. Specs: the measured killer is refused, 512²×4 still
      passes. `worker-comfyui-submission.spec.ts` 14 passed; executor baseline
      unchanged at 13 failed / 123 passed.
- [x] **C.12.20** _(found by C.11.07, 2026-09-12)_ **`rmbg-2.0` fails while all
      three BiRefNet models pass.** Two attempts, 13.8 s and 15.3 s of
      execution, both `Job processing failed` with no detail, the second on a
      freshly recycled worker. The model is present:
      `models/RMBG/RMBG-2.0/model.safetensors` (884,878,856 B) with
      `config.json`, `birefnet.py`, `BiRefNet_config.py`. _2026-09-12, offline:_
      **`timm` is ruled out** — `BiRefNetRMBG` execs a `birefnet.py` carrying
      the same `from timm.models.layers import …` lines and those three pass.
      The loaders do differ: `AILab_RMBG.py` `exec`s the remote code, picks the
      first `PreTrainedModel` subclass in `dir(module)`, and does a strict
      `load_state_dict`, falling back to
      `AutoModelForImageSegmentation.from_pretrained(..., trust_remote_code=True,     local_files_only=True)`;
      `AILab_BiRefNet.py` instantiates `module.BiRefNet` directly and calls
      `.half()`. Which step raises is not decidable from source. **The reason
      two attempts learned nothing is now fixed:** `Job processing failed` is
      worker-comfyui's own generic string, and
      `scripts/isis/runpod-catalog-run.mjs` discarded everything else. It now
      prints `output.errors[]` plus the whole status payload (base64 elided) on
      any non-`COMPLETED` status, and pulls
      `GET api.runpod.io/v2/serverless/<ep>/workers/<wid>/logs` immediately —
      while the worker is still alive, since they vanish with it — writing it
      beside the run's outputs. Capture never throws; it returns why it could
      not capture. One more $0.003 run should now name the traceback.\_ \_**ROOT
      CAUSE FOUND 2026-09-12, and it was OUR graph, not the pack.** The capture
      fix worked — the run returned
      `Node Type: RMBG, Node ID: 2,     Message: Error in image processing: Error in batch processing:     'process_res'`.
      `matte_node_class_map` sends `rmbg-2.0` to node class **`RMBG`** and the
      other three to **`BiRefNetRMBG`**, and the node carried a comment claiming
      the two had the "same input/output signature". They do not: `RMBG`
      declares `process_res` in `INPUT_TYPES` (default 1024) and reads it with a
      bare `params["process_res"]`, while `BiRefNetRMBG` neither declares nor
      reads it. In the ComfyUI **UI** an unset widget is filled from its
      default; in an **API-format graph** only the keys you send exist — and we
      sent none. Hence a `KeyError` for exactly one model of four, which is
      precisely the split C.11.07 measured. **The model file, `timm`, and the
      loader differences were all red herrings.** Fixed by declaring
      `process_res` as a catalog input and emitting it on the templated matte
      node in BOTH affected workflows (`matting-remove-background`,
      `chroma-txt2img-then-matte`); it is inert for BiRefNet because ComfyUI
      builds a node's call from the class's declared inputs and drops the rest.
      Verified through the real `renderCatalogWorkflow`:
      `rmbg-2.0 -> RMBG | process_res = 1024` and
      `birefnet-hr-matting ->     BiRefNetRMBG | process_res = 1024`.
      `libs/isis/workflows` 635 passed. **Two notes:** the catalog input schema
      has no `step` key (the migration harness rejected `step: 128`), and the
      worker-log endpoint returned only `: heartbeat` SSE frames — everything
      useful came from `output.details[]`. **Cost overrun, stated plainly:** the
      run cost **$0.1032**, not the ~$0.003 estimated, because the image
      endpoint could not place a worker so it was routed to the 96 GB video
      endpoint (~3x the rate) with a 94 s cold start. **C.11.07 stays open** —
      the fix is unproven on a render, and its cost row must be measured on the
      image endpoint.
- [x] **C.12.13** Image watermark stage for worker-comfyui outputs. The Isis
      provenance bundle requires a watermark hash for image/audio/video/3d-mesh;
      today the API records `watermark_hash NULL` with the written reason only
      when `ISIS_PROVENANCE_ALLOW_UNWATERMARKED_IMAGES=true` (submit-time guard
      refuses otherwise, before billing). Ship a real invisible watermark + hash
      in the API after the adapter returns the PNG, then turn the flag off
      everywhere. _Done 2026-09-12. **The requirement that shaped everything:
      the hash has to be a hash of something actually in the picture.** Hashing
      a provenance string and recording it as a watermark hash, without putting
      that string in the pixels, would be a fabricated result in the most
      literal sense, so the module ships `embedImageWatermark`,
      `extractImageWatermark` AND `verifyImageWatermark` — the last reads the
      image rather than the record, and has a test asserting it REFUSES a hash
      whose payload is not in the pixels. Method: LSB in the blue channel, one
      bit per pixel, payload framed with magic + length + CRC-32 and repeated
      (512 copies over a 1024²). `png-codec.ts` is a dependency-free PNG
      reader/writer (Node `zlib` only, 8-bit non-interlaced RGB and RGBA, every
      filter type, loud refusal of anything else) — no lockfile churn, and it
      round-trips a real C.11 ComfyUI output pixel-exactly. Payload
      `isis:v1;job=…;consent=…;wf=…;model=…;produced=…`, hashed with the same
      `sha256(payload)` the music provenance path uses. **Two defects found by
      measuring rather than reasoning:** (1) the first design read the frame
      header from copy 0, so damaging the start of the image lost the payload
      entirely — defeating the point of repeating it; frames are now a fixed 256
      bytes so every copy is independently readable, and the damage test failed
      against the old design and passes against this one. (2) Writing filter 0
      on every row — justified in a comment saying the watermark's noise would
      defeat the predictors anyway — produced files **93% LARGER** than
      ComfyUI's for identical pixels; the measurement showed the watermark
      itself costs 3.95% and the rest was the missing adaptive filter selection.
      With libpng's minimum-sum-of-absolute-differences heuristic the output is
      **1.9% larger than the original file, +0.5 s, max sample delta 1**, and
      the size is pinned by a test. **What it does not do, written down rather
      than discovered later:** spatial LSB survives a lossless re-save and the
      storage path, not JPEG/WebP re-compression, resize, crop or rotation — a
      provenance marker for what Isis stores and serves, not a forensic
      watermark; DWT-DCT is separate work. **The flag is narrowed, not deleted,
      and that was deliberate:** the executor was its only consumer, so dropping
      it would have made it dead while a comment claimed it still applied. The
      submit-time guard no longer refuses (there is a stage now); at completion,
      an output the stage could not mark is refused when the flag is off and
      kept with `watermark: { applied: false, reason }` when it is on. A job
      with no still to mark (a clip, a mask-only flow) is not covered either
      way, so `motion` work cannot be failed by an image policy. The stage is
      also the SINGLE writer of the `watermark` declaration — the old
      unconditional `applied: false` beside it was removed rather than left to
      be overwritten. Specs: 38 (14 codec incl. the real-PNG round trip and the
      size guard, 24 watermark incl. damage recovery and the refusal cases).
      Suites: generation-api `src/services` + `src/workflows` **508 passed**
      with the same 11 pre-existing `executor.spec.ts` failures;
      `npx tsc --noEmit` unchanged at 10 pre-existing errors. Runbook §2 and §2c
      rewritten; the env recipe now has the flag commented out, off being the
      right default. **Not yet proved on a live render** — the next
      worker-comfyui job through the dev stack is what will show the bundle
      carrying a real `watermarkHash`._
- [x] **C.12.14** Consent registry: the Studio attaches
      `consentId = consent_operator_isis_dev_studio` to every Chroma preset
      (operator's own consent for a typed prompt). Replace with a real consent
      record picker once a registry exists; the API already refuses jobs without
      a consent id before billing. _**Checked 2026-09-12: a registry exists and
      it is the wrong one, so this stays `[ ]` with the finding rather than
      being wired to something that does not mean what Isis needs.**
      `apps/lilith/svc-consent-management` is a complete, real registry —
      consent definitions, collection, validation (single and batch),
      withdrawal, per-user status, analytics and an audit trail. But its model
      is **data-processing consent keyed by `userId` and `purpose`** (its own
      seed purposes are things like "improve our services through anonymized
      research"), i.e. GDPR-shaped privacy consent for Lilith's end users. What
      a generation job's provenance bundle needs is a **media-rights** record —
      who consented to this likeness, voice or reference image being used to
      make this output — which is a different subject, a different grantor and a
      different lifetime. Pointing `consentId` at a privacy-consent row would
      make the bundle record a consent that was never given for this purpose,
      which is worse than the honest operator self-consent it has now. Isis also
      has no client for that service (no reference to it anywhere under
      `apps/isis` or `libs/isis`). **Two things are true and both should stay
      visible:** for a typed prompt with no likeness, operator self-consent is
      arguably the CORRECT record and not a placeholder at all; the gap is real
      only for jobs carrying reference images or voices, which the Chroma
      catalog does not yet offer. So the work this item is waiting for is a
      media-rights consent registry, not a client for the one that exists._
      _**Closed as scoped, user decision 2026-09-13.** Operator self-consent
      (`consent_operator_isis_dev_studio`) IS the correct record for a typed
      prompt with no likeness or voice, and every workflow in the Chroma and
      motion catalogs is prompt-driven; the Lilith consent service is GDPR
      privacy consent keyed by user and purpose and must not be pointed at. A
      media-rights registry (grantor, subject, scope, expiry, a Studio picker)
      becomes a new item the day a workflow takes a reference likeness or a
      voice — none does today._
- [x] **C.12.15** RunPod dashboard "Daily budget" card can show "Loading today's
      ledger…" for several seconds after login (seen in the real-browser pass);
      surface the fetch error or a skeleton instead of a stuck loading string.
      _Done 2026-09-12. The error path was already there and correct
      (`retry: false`, the message and the fail-closed note) — **the defect was
      the loading path having no way to distinguish slow from hung.** Both
      budget cards now render the app's existing `IsisLoadingState` skeleton
      (`role="status"`, `aria-live="polite"`) inside an `aria-busy` card instead
      of a bare sentence, so the shape says "loading" and the layout does not
      jump when the data lands. Past a 5 s threshold `describeSlowLoad` adds
      "Still waiting after Ns — longer than usual", which is the part that makes
      a stall visible **while it is still happening** rather than only if the
      query eventually errors. The notice deliberately does not say the request
      failed: nothing has observed a failure, and a card announcing a verdict
      the code has not reached is the same class of dishonesty this dashboard
      avoids elsewhere (a spec pins that wording). `useElapsedWhile` holds no
      interval while idle. The video ledger card had the identical bare string
      and got the identical treatment. Specs: 5 on the pure helper, 3 new on
      `RunPodPage` (skeleton + `aria-busy` against a never-settling promise, the
      error path still reached, the video card too) — 25 passed in that file.
      **Real browser, chromium, workers=1**
      (`e2e/runpod-budget-loading.spec.ts`, 1 passed in 7.3 s, API mocked at the
      HTTP boundary, $0): the route is held open for the whole test, and the
      assertions are that the skeleton line is actually PAINTED (non-zero
      bounding box — a zero-height element would look exactly like the frozen
      string it replaced), that the old string is gone, and that the elapsed
      line appears. Vite torn down, `lsof` confirms 5180 free, no chromium
      orphans._
- [x] **C.12.16** Running-job recovery after an API restart. Job 7d4280f9 was
      rendered by RunPod (148.98 s, billed) but lost: the API process restarted
      (tsx watch reload triggered by the commit hook's prettier pass) while the
      executor was polling, and the inline runner only claims pending/queued.
      Fix: persist the RunPod job id in job metadata at dispatch, and on startup
      re-attach to `running` jobs owned by a dead worker id (fetch
      `/status/<id>` and complete or fail them) instead of leaving them
      `running` forever. Landmine until then: never edit or commit app source
      while a job is in flight on the dev stack. _Done 2026-09-12. **The
      recovery is a re-attach, not a second render**, and that shaped the whole
      design: rather than a recovery service that rebuilds a completed job
      (which would be a second, divergent copy of the executor's completion tail
      — persistence, render passes, provenance, cost), the orphan is put back in
      the queue with its dispatch record intact and the ORDINARY path picks it
      up. `executeWithRuntime` sees the record and sets
      `attachToProviderJobId`/`attachToEndpointId`, the adapter skips `/run`
      entirely and polls the job that is already paid for, and every existing
      completion behaviour runs unchanged. **`/run` is never called on an
      attach** is the assertion that matters and it is a test, not a claim.
      `provider-dispatch-record.ts` is the one contract both sides of a restart
      read (`providerJobId`, `providerEndpointId`, `providerDispatchedAt`); a
      HALF-written record reads as no record, because attaching with an id but
      the wrong endpoint returns "not found", which is indistinguishable from a
      job that never existed — that is exactly how a live render gets declared
      lost. `orphaned-job-ownership.ts` answers "is the owner dead?" and answers
      `unknown` whenever it cannot prove it: `inline-<pid>` is probed with
      `process.kill(pid, 0)` (EPERM counts as alive), a pinned
      `ISIS_INLINE_JOB_RUNNER_ID` matching our own is a leftover by definition,
      and **anything else is left alone** — two processes on one job would
      double-bill it, which is worse than a stuck row. The sweep is
      startup-only, before the first claim, and that ordering is load-bearing
      for the self-id case. An orphan with no dispatch record is FAILED with
      `ORPHANED_WITHOUT_PROVIDER_JOB_ID` rather than left lying about being
      `running`. `JobService` gained two named methods
      (`recordProviderDispatch`, `requeueOrphanedJob`) instead of exposing a
      generic `update`, so the runner's injected slice still says what it needs.
      **Two findings worth keeping:** the dispatch hook must run before the
      first poll and cannot throw — the render is submitted and billing either
      way — so a persistence failure rides back on the result as
      `dispatchPersistenceError` and the executor logs it by name, since that
      job is now the unrecoverable kind; and the cost ledger was ALREADY
      idempotent per job id (`hsetnx` in `recordJobCost`), so a re-attached job
      cannot double-count its dollars. Specs: 8 on the adapter re-attach
      (including the negative `/run` assertion and the endpoint-required
      refusal), 8 on the dispatch record, 9 on ownership, 7 on the runner
      (dispatch persisted mid-execution, re-queue, alive/unknown left alone,
      unrecoverable failed). Suites: ai-providers `src/providers/comfy` 254
      passed; generation-api `src/services` + `src/workflows` 456 passed with
      the same 11 pre-existing `executor.spec.ts` failures. `npx tsc --noEmit`
      unchanged at 10 pre-existing errors in 8 files. Runbook §2c documents the
      behaviour and the two log lines to watch for._
- [x] **C.12.17** Cold-start budget vs execution budget. Job d1e87d06 (17:34Z)
      landed on a fresh EU-RO-1 host that pulled the 14.7 GB worker image for ~4
      min before the container started; the executor's single 300 s timeout
      (queue + boot + GPU) expired, cancelled the RunPod job (container stopped
      17:39:28Z, GPU seconds already billed) and retried. Split the budget: a
      queue/boot allowance (RunPod `delayTime`, unbilled) separate from the GPU
      execution cap that mirrors the endpoint's `executionTimeout`; do not retry
      a job whose provider execution already started. _Done 2026-09-12 — and the
      defect turned out to be **three** places deep, not one._
      `runpod-poll-budget.ts` is the new pure module that owns both clocks:
      `evaluatePollDeadline` measures the queue phase from submission and the
      execution phase from execution start, so boot time can no longer be
      charged against the GPU budget, and it returns `retryable: false` the
      moment execution has started. `observeExecutionStart` takes the start
      instant from RunPod's `startedAt`, else `submittedAt + delayTime`, else
      the observation instant — the last is a documented approximation, late by
      at most one 2 s poll, which **shortens** the billed budget rather than
      lengthening it, and the instant is frozen once set so a status response
      that loses `startedAt` cannot rewind the billed clock. `pollForCompletion`
      now consults it. **The second place was a hidden second deadline:**
      `maxPollingAttempts` was 150 ticks × 2 s = exactly 300 s, so it would have
      silently become the binding limit the moment the real budgets grew past
      it; `minimumPollAttemptsFor` derives a floor from both budgets and the
      attempt guard is now only a backstop against a stuck clock. **The third
      was the retry itself, and it was the one that spent the money:**
      `error-boundary.ts`'s `EXECUTION_TIMEOUT` handler retried on attempt count
      alone and never read `error.retryable`, so marking the adapter's error
      non-retryable would have changed nothing on its own. It now honours the
      flag, the executor's own race became a BACKSTOP at queue + execution + 30
      s grace (it used to fire at the GPU cap and was the thing that actually
      killed d1e87d06 mid-render), `isProviderResultRetryable` refuses a retry
      whenever `providerExecutionStarted` is true regardless of what anything
      else says, and `providerResultErrorCode` stops calling a provider timeout
      `OUTPUT_GENERATION_FAILED` — the service maps every thrown `RunPodError`
      to `status: 'failed'`, which had been routing timeouts straight past the
      timeout handler. Allowance default 600 s (2.5× the measured 4-min worst
      boot; nothing in the window is billed), overridable by
      `ISIS_RUNPOD_QUEUE_BOOT_TIMEOUT_MS` — which the kill-switch drills
      C.11.12/V.11.04 now need, since they measure exactly this wait; runbook §2
      documents it. A zero or malformed override is ignored, not obeyed. Specs:
      16 on the pure module (including a replay of d1e87d06 that fails against
      the old single budget and passes against the split one), 14 on the
      executor-side rules. Suites: ai-providers comfy 111 passed (80 + 31);
      generation-api `src/services` 248 passed; `src/workflows` 184 passed with
      the **same 11 pre-existing `executor.spec.ts` failures measured at HEAD
      before the change** (verified by reverting the six touched files to HEAD,
      re-running, and restoring). `npx tsc --noEmit` unchanged at the app's
      pre-existing 10 errors in 8 files, both of `executor.ts`'s present
      verbatim at HEAD; the lib typechecks clean.

## Video design decisions (defaults chosen 2026-09-11; each is one line to flip)

- **D-V1 Second endpoint, not a bigger first one.** `isis-comfyui-video`
  (`workersMax 1`, `workersMin 0`, `idleTimeout 10`, `executionTimeout 900`,
  FlashBoot on, same volume, same image) on **H100 80 GB** so that fp16 14B Wan
  experts (28.6 GB each), Animate (34.6 GB), VACE (34.7 GB) and LTX-2.3 22B (46
  GB + 24 GB Gemma) load without CPU offload. The image endpoint keeps its 300 s
  / 4090 bounds untouched. Running Wan on L40S instead is a measured
  cost-optimisation item (V.11.06, only if asked), not an assumption.
- **D-V2 One worker image.** The slim Dockerfile stays single-source and gains
  the video node packs; both endpoints pin the same digest and share one
  node-class snapshot and one smoke test. If the image endpoint's cold start
  regresses by more than 20 s after the rebuild (measured in V.11.01 vs the
  C.11.01 number), split into `runpod-comfyui-slim` and
  `runpod-comfyui-slim-video` (V.01.08, conditional).
- **D-V3 New catalog category `motion/`**, registered only under the
  worker-comfyui gate (extend `WORKER_COMFYUI_ONLY_CATEGORIES`), so the existing
  `video/` and `flagship/` graphs bound to retired images and quantized weights
  are neither reused nor broken.
- **D-V4 Videos travel by the volume's S3 API, not by base64.** Outputs:
  `BUCKET_ENDPOINT_URL` on the video endpoint points at the volume's S3 endpoint
  (`s3api-eu-ro-1.runpod.io`, bucket = volume id); the API fetches with the
  SigV4 client `runpod-provision.mjs` already has. Inputs above the payload
  threshold (V.05.01) are PUT to `/runpod-volume/inputs/<jobId>/` before submit
  and read by the core `LoadVideo` node through an `input/volume` symlink baked
  into the image. Small inputs may still ride `input.images[]`.
- **D-V5 Full-precision only, LoRAs allowed.** The lightx2v 4-step LoRAs and the
  Animate relight LoRA are LoRAs, not quantization; they ship as opt-in
  `speed_mode` / `relight` inputs. The fp8 umt5, fp8/fp4 Gemma and fp8/int8
  Wan/LTX files that sit beside the full weights are never copied.
- **D-V6 Volume grows once, to 500 GB** (see the footprint table); RunPod
  volumes never shrink, so this is the one irreversible cost decision of the
  extension: **+$28/month** over today's 100 GB. V.02.01 asks for the user's
  explicit `--yes`.

## Video footprint (full precision, from the verified sizes above)

| Artifact                                           | GB         |
| -------------------------------------------------- | ---------- |
| Wan2.2 T2V A14B high + low fp16                    | 57.16      |
| Wan2.2 I2V A14B high + low fp16                    | 57.16      |
| Wan2.2 Animate 14B bf16                            | 34.55      |
| Wan2.1 VACE 14B fp16                               | 34.68      |
| umt5-xxl fp16 (shared by all Wan rows)             | 11.37      |
| wan_2.1 VAE + clip_vision_h                        | 1.51       |
| lightx2v 4-step LoRAs ×4 + Animate relight LoRA    | 6.35       |
| LTX-2.3 22B dev                                    | 46.15      |
| LTX-2.3 spatial x2 + temporal x2 upscalers         | 1.26       |
| Gemma 3 12B it bf16 (Comfy-Org single file)        | 24.38      |
| FlashVSR v1.1 (4 files)                            | 6.95       |
| GIMM-VFI (4 files)                                 | 0.29       |
| Animate preprocess ONNX (yolov10m + ViTPose, est.) | ~1.5       |
| **New total**                                      | **~283.3** |
| Already on the volume (C.02)                       | 70.07      |
| **Grand total**                                    | **~353.4** |

353 GB ÷ 0.8 (the lint's 20 % headroom) = 442 GB → provision **500 GB**
($35.00/month at $0.07/GB). The LTX-2.3 distilled checkpoint (46 GB) and the
distilled LoRA (7.6 GB) are NOT in the plan: `ltx-2.3-22b-dev` is the named
model; distilled is a V.12 option.

## Arsenal footprint (full precision, from the 2026-09-13 facts; sizes are the LFS or Civitai byte counts, nothing pulled)

| Artifact                                                                                        | GB         |
| ----------------------------------------------------------------------------------------------- | ---------- |
| LTX-2.5 dev transformer, Gemma 4 with-proj, video and audio VAEs, upscalers                     | 71.37      |
| LTX-2.5 distilled LoRA, Ingredients IC-LoRA, pixel-spatial-upscaler IC-LoRA                     | 10.54      |
| Wan2.2-Animate-2 base and distilled                                                             | 65.58      |
| SAM 3.1 multiplex                                                                               | 1.75       |
| SeedVR2 3B, 7B and VAE                                                                          | 23.76      |
| Z-Image base, Qwen3-4B encoder, base union, Turbo union                                         | 33.77      |
| Depth Anything 3 mono large                                                                     | 1.34       |
| HiDream-O1-Image Dev                                                                            | 16.37      |
| FLUX.2 klein 4B and FLUX.2 VAE (encoder shared with Z-Image)                                    | 8.09       |
| Qwen-Image-2512, Edit-2511, Qwen2.5-VL-7B, VAE, InstantX union and inpaint                      | 106.32     |
| SCAIL-2 and its DPO and relight LoRAs                                                           | 35.25      |
| Civitai checkpoints: UnGloryHail, CyberRealistic ZIT v8, ZIT AIO                                | 49.69      |
| Civitai LoRAs, Chroma (NiceGirls, NSFW Realism)                                                 | 1.27       |
| Civitai LoRAs, Z-Image (five files)                                                             | 0.52       |
| Civitai LoRAs, Wan service tier (five high/low pairs)                                           | 3.12       |
| Civitai LoRAs, Wan internal-only (four high/low pairs)                                          | 2.45       |
| **New total**                                                                                   | **431.19** |
| On the volume and manifest today (lint, 50 rows)                                                | 367.17     |
| **Peak — every row present, nothing retired**                                                   | **798.36** |
| Retired after proof: LTX-2.3 set 80.38, Animate-1 with relight 35.99, DA-V2 1.34, RMBG-2.0 0.88 | −118.59    |
| **Steady state**                                                                                | **679.77** |

Sizing by the lint's rule: 798.36 GB ÷ 0.8 = 998 GB. A 1000 GB volume would pass
with 20.16 % headroom — one more row of any size breaks it — so the volume goes
to **1024 GB**: 22.0 % headroom at peak, 33.6 % at steady state. Price is tiered
(1000 GB × $0.07 plus 24 GB × $0.05) = **$71.20/month**, up from $35.00; that is
$0.0989/hour against a $9.13 balance, about 3.8 days (A.00.02). The 24 GB above
the tier line cost $1.20/month; they are what keeps the manifest green with
every row present.

_2026-09-13, option B:_ the peak and steady-state figures above now size the
**Hetzner library** (798.36 GB peak and about 680 GB steady, both inside the
account's included 1 TB, which `isis/outputs/` also draws on). The RunPod side
is a 400 GB cache sized by L.02.03's invariant, not by the lint's 20 % rule:
pinned core 212.26 GB plus the largest unpinned family, Qwen-Image at 106.32 GB,
is 318.58 GB, under 95 % of 400.

## Toolbox extension footprint (from the 2026-09-14 facts; nothing pulled)

| Artifact                                                                                                    | GB            |
| ----------------------------------------------------------------------------------------------------------- | ------------- |
| lightx2v I2V 480p rank-64 distill LoRA                                                                      | 0.74          |
| Wan-Dancer-14B global and local (BF16)                                                                      | 68.98         |
| Wan2.2-S2V 14B and wav2vec2 large (bake-off)                                                                | 33.22         |
| HuMo 17B and Whisper large v3 (bake-off)                                                                    | 37.20         |
| Uni3C controlnet                                                                                            | 3.99          |
| The Walk Normal pair                                                                                        | 0.61          |
| Qwen-Image-Edit 2511 native: Multiple Angles, Lightning 4-step and 8-step, Anyone Cosplay                   | 2.47          |
| Qwen-Image-Edit 2509-trained: Try-On, Outfit Extractor, Pose Transfer, Next Scene, Relight, Light Migration | 1.65          |
| Z-Image look LoRAs (five files)                                                                             | 0.60          |
| Style LoRAs on Chroma, Z-Image, Qwen and LTX-2.5 (seventeen files)                                          | 3.98          |
| NetaYume Lumina v4 all-in-one                                                                               | 10.62         |
| **New total**                                                                                               | **164.06**    |
| Library at A.00.03, before later retry pulls                                                                | 813.38        |
| Pending A.05.03 retirements                                                                                 | −117.71       |
| **After the extension, both bake-off models present**                                                       | **859.73**    |
| After deleting the E.03.04 loser                                                                            | 822.53–826.51 |
| Qwen-Image-Layered, only on the user's go                                                                   | +41.12        |
| Illustrious XL v2.0, listed and not pulled                                                                  | (6.94)        |

Every figure stays under the 900 GB alarm line, but only in that order:
retirements first (E.00.02). On the 400 GB cache the largest new family is
Wan-Dancer at about 69.7 GB with its LoRA (umt5, CLIP vision H and the Wan 2.1
VAE are shared rows), inside the 188 GB rotating space beside the pinned core.

## Video cost model (all eight matrix workflows MEASURED 2026-09-12/13; the rest are still stickers)

Rate: the ledger bills at the dearest card the endpoint may assign, **H200 at
$5.93/h = $0.001647/s**. V.11.01's billing evidence suggests the cards we
actually get are the **A100 80 GB tier at $2.72/h = $0.000756/s**, so a second
figure is given for the measured rows — the truth is between them and depends on
placement, which RunPod's API does not report. **Measured 2026-09-13 from the
account balance:** a four-stage session (739.4 s of execution on an RTX PRO 6000
Blackwell Server Edition, the card `GET /workers` named) moved the balance
**$0.813** once it settled ($10.0905 at 07:32Z → $9.2772, unchanged from 08:13Z
on), $0.037 of it volume rent, i.e. **$0.00105/s** — between the A100 and H100
figures and 2.3x under the $0.002400/s the ledger is configured with. RunPod
posts a job's charge minutes after it ends: read 90 s after the last job the
same balance showed $0.608, so a figure taken that early is wrong.

**Billing is execution only.** Queue wait is not worker time and RunPod does not
charge it; the ledger charged it until 2026-09-12 and overstated V.11.01 by 4x.

| Item                                          | Basis                                       | Estimate                               |
| --------------------------------------------- | ------------------------------------------- | -------------------------------------- |
| Network volume 500 GB                         | $0.07/GB/month                              | $35.00/mo                              |
| Loader pod, video model pull (288.23 GB)      | **measured** V.02.04                        | **$0.0572 one-off**                    |
| **Wan2.2 T2V 14B, 81 f, 480p, 20 steps**      | **measured** 28.486 s/MP-frame              | **$1.52** / $0.70 on A100              |
| **Wan2.2 I2V 14B, 81 f, 480p, 20 steps**      | **measured** 31.086 s/MP-frame              | **$1.66** / $0.76 on A100              |
| **SAM 3 track → VACE inpaint, 81 f, 480p**    | **measured** 26.045 s/MP-frame              | **$1.39** / $0.64 on A100              |
| **BiRefNet HR matte, 81 f, 480p**             | **measured** 2.074 s/MP-frame               | **$0.11** / $0.05 on A100              |
| **GIMM-VFI ×2, 81 f, 480p**                   | **measured** 2.539 s/MP-frame               | **$0.14** / $0.06 on A100              |
| Wan2.2 T2V 14B, 81 f, 720p, 20 steps, warm    | sticker ~300 s                              | ~$0.40                                 |
| Wan2.2 T2V/I2V, lightx2v 4-step, 720p, warm   | sticker ~50 s                               | ~$0.07                                 |
| **Wan2.2 Animate, 77 f, 480p**                | **measured** 25.661 s/MP-frame              | **$1.30** / $0.63 on A100              |
| VACE 14B edit (standalone), 81 f, 480p, warm  | sticker ~200 s                              | ~$0.27                                 |
| **LTX-2.3 22B dev, 121 f, 1280×704 + audio**  | **measured** 15.665 s/MP-frame              | **$2.81** / $1.35 on A100              |
| SAM 3 video track (standalone), 81 f          | sticker ~30 s                               | ~$0.04                                 |
| **FlashVSR v1.1, 81 f 480p → 2x**             | **measured** 0.558 s/output MP-frame        | **$0.12** / $0.06 on A100              |
| Cold start, container start → first clip done | **≤ 45 s incl. a 25 s render** (2026-09-13) | placement is the wait                  |
| 10 clips/day bursty (mixed), incl. volume     | sticker                                     | ~$110/mo                               |
| **V.11 proof matrix, actual spend**           | **measured**, 8 clips + 4 dead              | **~$1.65–2.70** (+$0.78 on 2026-09-13) |

Two cautions about the measured rows. They were taken at **33 frames** and
scaled to the 81-frame reference by the per-megapixel-frame rate, so they assume
cost is linear in frames — reasonable for a per-frame sampler, unverified at 81.
And the three Wan-family rows are far above their old stickers (7.7x, 8.4x,
2.8x) while the two per-frame utilities are **below** theirs; guessing was wrong
in both directions, which is the argument for measuring rather than for padding.

**The cold start is still unmeasured and cannot be read off `delayTime`.** That
field is wall time from submission, and on a supply-starved endpoint it is
dominated by queue wait: V.11.01 measured 528 s and the image endpoint 1 315 s,
almost all of it waiting for a card rather than booting. Isolating the boot
needs a warm session's total charge compared against the sum of its execution
times.

**The loader-pod row is now measured, not sticker.** It read "~2–4 h CPU pod, <
$3 one-off", which was a conservative ceiling nobody had costed. The first
loader pod already ran, for the 10 chroma rows:
`infra/runpod/volumes/isis-chroma-models.manifest.json` puts that set at **70.07
GB**, and C.02.08 recorded the account's TOTAL spend at that point as **$0.0605
— volume creation, loader pod and pull together**. The video set is **288.23
GB**, 4.11x the data, so the same SKU at the same throughput lands near
**$0.25**. What would actually cost $3 is running the pull on a GPU pod (an A100
at $1.19/h for 3 h is $3.57) — which V.02.04 explicitly forbids: "CPU pod in
EU-RO-1, no GPU". _Caveat, stated because the number is inferred: C.02.06's
evidence row is still literally "pending — pod id, SKU, start/end UTC, cost", so
the first pull's wall clock was never recorded and this scales by BYTES, not by
a measured GB/h. V.02.04 records the real figures._ _The volume's own $0.049/h
($35/month at 500 GB, confirmed live as `currentSpendPerHr` with nothing else
running) accrues whether or not the pull happens, so it is not a marginal cost
of pulling._

Daily video budget default `ISIS_RUNPOD_VIDEO_DAILY_BUDGET_USD=6.00` (separate
ledger key from the image endpoint), i.e. roughly 15 warm clips or 8 clips with
cold starts before the API refuses with 429.

## Suggested order for the video track

V.00 → V.01 (image rebuild, unattended CI) → V.02 (volume grow + loader pod,
unattended) → V.04 (video budget + caps) → V.05 (video transport) → V.06
(catalog schema + executor) → V.08 (all graphs) → V.01.09 + V.06.06 offline
proofs for every graph → V.03 (endpoint) → V.11.01 (the only standalone live
clip) → V.09 (dashboard video) → V.11.02 (the remaining seven clips in ONE
warm-chained session) → V.11.03–V.11.05. Do not start V.02.03 (the 283 GB pull)
before V.01.06's smoke test proves the node classes exist — a volume full of
weights no node can load is the expensive failure mode here.

## V.00 Phase control and evidence

- [x] **V.00.01** Add `## V.01`–`## V.11` headings to
      `docs/agents/isis-chroma-runpod-evidence.md` mirroring the C.xx ones
      (endpoint id, volume grow result, job ids, seconds, USD, GPU assigned,
      output sha256 + duration + fps + resolution + audio yes/no). _Done
      2026-09-12: a `# Video extension evidence (V.01–V.11)` block at the end of
      the file (the C.xx sections were left in order; the stray V.02 section
      that sat between them moved into it). Each heading states what a row must
      record, and the block's preamble states the `proof_level` rule — a
      workflow with no row here is not proved at all._
- [x] **V.00.02** Extend the `/tmp/isis-chroma-env.sh` recipe (C.00.03) with
      `RUNPOD_COMFYUI_VIDEO_ENDPOINT_ID`, `ISIS_RUNPOD_VIDEO_DAILY_BUDGET_USD`,
      `ISIS_COST_RATE_RUNPOD_VIDEO_USD_PER_SECOND` (H100 = 0.001331),
      `ISIS_RUNPOD_VIDEO_INPUT_INLINE_MAX_BYTES` (V.05.01), and the volume S3
      vars. Verify by length only; delete at session end. _Done 2026-09-12 in
      the runbook's §2 block, plus `RUNPOD_VOLUME_ID` and `RUNPOD_S3_ENDPOINT`,
      and the length echo now prints the video endpoint too. The whole block
      ships **commented out** until V.03.04 creates the endpoint: an unset id
      fails loudly, an empty one submits to nowhere._
- [x] **V.00.03** Update `TODOS/index.md` line 307 to mention the video
      extension; update the memory note (`isis-chroma-runpod-mvp.md`) with the
      video endpoint id, the 500 GB decision, and "SAM 3.1 has no ComfyUI loader
      as of 2026-09-11". Commit + two-line push. _`TODOS/index.md:307` already
      carried the video extension (checked, not assumed). The memory note
      carries the 500 GB decision and the SAM 3.1 finding, and gained the
      2026-09-12 session block. **The video endpoint id is not recorded because
      the endpoint does not exist** — V.03.04 creates it; recording a
      placeholder id is how a dead endpoint gets submitted to (see the deleted
      `ac988l8is5axkf` landmine)._

## V.01 Worker image: video node packs (rebuild, still no models)

- [x] **V.01.01** Extend `docker/runpod/comfyui-slim/Dockerfile` with
      git-SHA-pinned clones (same pattern as ComfyUI-RMBG, SHA recorded into
      `/opt/oshun/build-manifest/<pack>.sha`, `.git` removed):
      `Kosinkadink/ComfyUI-VideoHelperSuite@4d907bee61e92c2e65af3bd6383a4e4d356126d1`,
      `Fannovel16/comfyui_controlnet_aux@59b1fc411ede8623b2997855b8018f0b3b6cf49f`,
      `kijai/ComfyUI-WanAnimatePreprocess@0e0b6a2a555625acf4d4aefb780e27d06937132f`,
      `kijai/ComfyUI-GIMM-VFI@4c9a3123762af85e7c796e41737da0b70c75d72d`,
      `lihaoyun6/ComfyUI-FlashVSR_Ultra_Fast@4820b3f02347bddcbbb9a5a85ab7638fe976366e`,
      `PozzettiAndrea/ComfyUI-SAM3@de0ff5d2c2ea435d29f800abfa568cffdfb94773`.
      Python deps pinned in one `requirements-video.txt` in the image dir:
      `cupy-cuda12==13.3.0`, `onnxruntime-gpu`, `opencv-python-headless` (never
      `opencv-python` — no X libs in the image), `triton`, `av`,
      `imageio-ffmpeg`; `ffmpeg` apt package present (VHS and `SaveVideo` need
      the binary). No model downloads, no secrets. _Code landed 2026-09-12;
      **stays `[ ]` until a build proves it** (V.01.06 is that build). The clone
      loop is a COPYed `install-video-packs.sh`, not an inline RUN, because
      **Docker expands `$1` itself in a shell-form RUN** and a loop using
      positional parameters would have had them silently emptied — the first
      draft had exactly that bug and `bash -n` plus a real local run caught it.
      Run against the live repos here: five of six cloned with every resolved
      SHA matching its pin; the sixth (SAM3) was cut short by a shell timeout,
      and its bypass premise was proved from source instead.
      `requirements-video.txt` is reconciled, not concatenated, with a written
      reason per omission — **four packs ask for `opencv-python`** whose GUI
      build needs libGL, so headless goes in once. Correction: GIMM-VFI wants
      `cupy-cuda12x>=13.3.0`; `cupy-cuda12` (the tracker's spelling) is not the
      PyPI name for the CUDA 12 wheel, so the pin is `cupy-cuda12x==13.3.0`.
      **Build `95f5cc15` (2026-09-12 02:24:43Z) COMPLETED and proves it**: all
      six packs cloned with every resolved SHA asserted against its pin, both
      dependency checks passed (`video deps import ok`,
      `gpu-only + optional deps installed ok`), and the smoke ended
      `ok — 64 required classes present, 1071 classes total`._
- [x] **V.01.02** ComfyUI-SAM3 installer bypass: read `install.py`,
      `prestartup_script.py`, `comfy-env-root.toml` at the pinned SHA; install
      its `requirements.txt` into `/opt/venv` directly and neutralise the
      `comfy-env`/pixi path (delete `prestartup_script.py` or set whatever env
      var it honours — read the source, do not guess). Assert at build time that
      `import nodes.load_model` succeeds without network. Record the exact
      mechanism in the README. _Done 2026-09-12, and **the premise in this item
      is wrong**: at `de0ff5d2` the pack ships **no `prestartup_script.py` and
      no `requirements.txt`**. Its only coupling to comfy-env is two lines —
      `install.py` calls `comfy_env.install()` and the root `__init__.py` calls
      `comfy_env.register_nodes()`. So the bypass is neither an env var nor a
      deleted prestartup script: `install.py` is removed, and the root
      `__init__.py` is replaced with a direct
      `from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS`.
      Proved from source with `ast`: `nodes/__init__.py` assigns both names at
      module level and imports no `comfy_env`. Dependencies came from the pack's
      own `nodes/comfy-env.toml` into `requirements-video.txt` — **which
      independently lists `pycocotools` for SAM 3**, corroborating C.12.18 from
      a different author's file. Mechanism recorded in the README. \_Stays `[ ]`
      only for the build-time `import nodes.load_model` assertion, which the
      V.01.06 build will carry._
- [x] **V.01.03** Volume folder mapping for the new packs: extend
      `extra_model_paths.yaml` with `interpolation: models/interpolation/`,
      `detection: models/detection/`,
      `latent_upscale_models:     models/latent_upscale_models/`,
      `audio_encoders: models/audio_encoders/`; add symlinks (same pattern as
      the RMBG/sam3 ones) for packs that bypass `folder_paths`:
      `/comfyui/models/FlashVSR → /runpod-volume/models/FlashVSR` (confirm the
      folder name the pack's model combo expects for the v1.1 files by reading
      `nodes.py:35-60`), and `/comfyui/input/volume →     /runpod-volume/inputs`
      for `LoadVideo` (D-V4). controlnet*aux annotator checkpoints: set its
      ckpt-dir env var (read the pack's `utils.py` for the exact name) to
      `/runpod-volume/models/controlnet_aux/` so DWPose / Depth Anything never
      download at request time. \_Done 2026-09-12. **The FlashVSR folder is
      `FlashVSR-v1.1`, not `FlashVSR`**: `nodes.py:140-141` joins
      `folder_paths.models_dir` with the model combo value verbatim
      (`"FlashVSR"` | `"FlashVSR-v1.1"`), and a missing directory makes the pack
      `snapshot_download` the whole repo at request time — the manifest
      destPaths were corrected to match. The controlnet_aux variable is
      **`AUX_ANNOTATOR_CKPTS_PATH`** (`src/custom_controlnet_aux/util.py:41`),
      set in the Dockerfile with `AUX_USE_SYMLINKS=False`. `extra_model_paths`
      gained `audio_encoders`, `detection`, `interpolation`,
      `latent_upscale_models`; `entry.sh` gained the `FlashVSR-v1.1` and
      `input/volume` links and the smoke test now asserts all four. Exercised
      for real against a throwaway root: four links created, dangling volume
      tolerated.*
- [x] **V.01.04** README: add the video contract — video outputs arrive in
      `images[]` because `SaveVideo` reports under the `images` history key
      (verified from ComfyUI 0.34.0 `PreviewVideo.as_dict`); `SaveAudio` output
      is NOT collected, so audio is always muxed; `BUCKET_ENDPOINT_URL` family
      for S3 output; the `input/volume` symlink; the list of packs and why each
      exists. _Done 2026-09-12: a "Video contract" section covering why video
      arrives in `images[]` (`SaveVideo` reports under the images history key
      and the handler collects only that), why audio is always muxed
      (`SaveAudio` output is NOT collected, so an audio-only save is silently
      dropped), the bucket env family, the `input/volume` symlink, and a table
      of the six packs with the reason each is there, plus the three details
      that cost real time: SAM3's comfy-env bypass, `FlashVSR-v1.1` being a
      folder name rather than a label, and never `opencv-python`._
- [x] **V.01.05** Extend `smoke-test.sh` `REQUIRED_CLASSES` with the core video
      classes (`WanImageToVideo`, `WanFirstLastFrameToVideo`, `WanVaceToVideo`,
      `TrimVideoLatent`, `WanAnimateToVideo`, `ModelSamplingSD3`,
      `LTXAVTextEncoderLoader`, `LTXVAudioVAELoader`, `LTXVAudioVAEDecode`,
      `LTXVEmptyLatentAudio`, `LTXVConcatAVLatent`, `LTXVSeparateAVLatent`,
      `LTXVDualCFGGuider`, `LTXVImgToVideoInplace`, `EmptyLTXVLatentVideo`,
      `LoadVideo`, `GetVideoComponents`, `CreateVideo`, `SaveVideo`, `SaveWEBM`,
      `LoadAudio`) and the pack classes (`VHS_LoadVideo`, `VHS_VideoCombine`,
      `DWPreprocessor`, `DepthAnythingV2Preprocessor`, `CannyEdgePreprocessor`,
      `OnnxDetectionModelLoader`, `PoseAndFaceDetection`, `DrawViTPose`,
      `DownloadAndLoadGIMMVFIModel`, `GIMMVFI_interpolate`, the FlashVSR node
      class (read `nodes.py` `NODE_CLASS_MAPPINGS` — the name was not captured
      today), `LoadSAM3Model`, `SAM3VideoSegmentation`, `SAM3Propagate`,
      `SAM3VideoOutput`). Missing class = red build. _Code landed 2026-09-12;
      **stays `[ ]` until the build runs it.** 61 classes, no duplicates. The
      FlashVSR name the item could not capture is **`FlashVSRNode`**
      (`nodes.py:543`, beside `FlashVSRNodeAdv` and `FlashVSRInitPipe`). Every
      pack key was read from that pack's own `NODE_CLASS_MAPPINGS` rather than
      inferred from a class name, because they differ: `VHS_LoadVideo` is the
      class `LoadVideoUpload`._
- [x] **V.01.06** ~~Rebuild through `.github/workflows/runpod-comfyui-slim.yml`
      (a push touching `docker/runpod/comfyui-slim/**`).~~ Store the new
      object-info JSON as
      `infra/runpod/endpoints/node-classes/worker-comfyui-5.10.0-video.json`.
      _**Stored 2026-09-13 — and not through a container.** The smoke test now
      prints the snapshot, reduced to the validator's fields (per class:
      `input.required`, `input.optional` without tooltips, `output`,
      `output_name`), as gzip+base64 `OBJINFO i/n` lines at the very end of the
      build, and `scripts/isis/runpod-build-snapshot.mjs` reads them back from
      `getBuildLogs` (the newest 500 lines are all it returns), refusing to
      write unless every chunk is present, the sha256 matches and the build
      COMPLETED. Build `f4fbb9fb` (commit `fa81159f3`): 1071 classes, 75 chunks,
      sha256 `06a7f453…` verified. Combo lists carry the shadow volume's names,
      i.e. exactly the manifest destPaths. The GPU route was tried first and is
      why this exists: a CPU pod cannot hold the image (`containerDiskInGb` ≤ 20
      vs 30 needed) and a serverless worker in EU-RO-1 sat
      `throttled`/`initializing` for over an hour at $0 before being cancelled.
      The raw file with tooltips is not stored; the reduction is named in
      `provenance.reduced`. Evidence block `## V.01.06`._ ~~Record image digest,
      compressed size, and size delta vs the C.01.09 digest.~~ _**The build half
      is DONE and the CI half is superseded**, on the same user decision that
      superseded C.01.09: RunPod is connected directly to the GitHub repo and
      builds the image itself, so `.github/workflows/runpod-comfyui-slim.yml` is
      not the build path and there is no CI build to trigger._ _Build
      `95f5cc15-6f81-4403-81a2-0e7d465373f9` **COMPLETED** 2026-09-12T02:24:43Z
      from commit `a5ac709682` (branch `runpod-comfyui-slim`), image tag
      `…-dockerfile:a5ac70968`, and it is the image endpoint's ACTIVE build —
      re-confirmed in the console's Builds panel 2026-09-12 (rule 9). The smoke
      test's own last line:
      **`[smoke] ok — 64 required classes present, 1071     classes total`**,
      and the smoke is fatal (`exit "${status}"`), so that is evidence and not
      an assertion — the two builds before it FAILED on exactly that check. Full
      detail, including all six pack SHAs asserted against their pins, is in the
      evidence file._ _**Stays `[ ]` for one deliverable only: the object-info
      JSON is not in the repo.** It exists at
      `/opt/oshun/build-manifest/object_info.json` INSIDE the image, so
      extracting it needs a running container — which is why it waits on V.11.01
      rather than on anything in CI. The digest and compressed size are struck
      through because RunPod exposes neither for a git-integration build
      (C.01.09); the commit SHA is the handle._ _**A note on this item claiming
      GitHub Actions' billing block was "the true blocker for the object-info
      snapshot, V.01.09, V.06.06 and the whole V.11 chain" was WRONG and is
      withdrawn.** Every Actions run has indeed failed at queue since 2026-09-11
      — that fact stands, and it does block the repo's ordinary CI — but it
      blocks nothing in this initiative, because Actions was decided against as
      the build path on 2026-09-11 and the evidence file already recorded that.
      Caught by the user._
- [x] **V.01.07** Point BOTH endpoints (`comfyui-chroma`, `comfyui-video`) at
      the new digest in `desired-state.json`; drift check green on the image
      endpoint after `endpoint update`. **Done 2026-09-12 — and "the new digest"
      is a premise that does not survive contact with the build model.** RunPod
      builds the image itself from the repo, and a git build produces **no
      digest**: `image` is `null` on both entries and the commit SHA is the only
      handle (the templates are invisible to REST and GraphQL, so nothing can be
      compared against a tag either). What CAN be asserted, and now is, is that
      both endpoints resolve to the SAME source —
      `imageSource.kind     runpod-github`, repo `GreyChimp/oshun`, branch
      `runpod-comfyui-slim`, Dockerfile `docker/runpod/comfyui-slim/Dockerfile`,
      byte-identical across the two entries — which is the property the item was
      reaching for: one worker image, two endpoints. **Drift check green on
      BOTH**, not just the image endpoint: `no drift (2 endpoints checked)`
      after the bare-run fix that stopped it silently checking only half the
      fleet.
- [x] **V.01.08** _(conditional, D-V2)_ If V.11.01 shows the image endpoint's
      cold start regressed > 20 s versus C.11.01, split the Dockerfile into a
      base stage and a `-video` stage, publish two tags from the same workflow,
      and re-point the endpoints. Leave `[ ]` unless exercised. _2026-09-13:
      still not exercisable. D-V2's trigger is a >20 s cold-start REGRESSION on
      the image endpoint, and that number is not observable while `delayTime` is
      dominated by queue wait in a starved region (evidence § D-V2). A way to
      measure it now exists — the worker's own log timestamps (`worker is ready`
      → ComfyUI's listen line → first job) read through `runpod-worker-log.mjs`
      — but it needs one placed worker (a model-free probe, roughly $0.01) and a
      card in EU-RO-1. If measured and under 20 s, this box stays `[ ]` by its
      own wording; only a real regression would open the Dockerfile split. What
      is comparable today says the render got FASTER after the rebuild (150 127
      ms → 82 014 ms on the identical job)._ _**Closed 2026-09-13: the condition
      was measured and is false, so the split is not needed.** User asked for
      the measurement. Model-free `EmptyImage` probe on the image endpoint
      `6jye7vngg4i685` right after build `5a27c020` (commit `63ec3eb6b`)
      released, so a new container had to start: job
      `41c62dbe-304e-4e70-af49-de656fb9c92c-e2`, `delayTime` 10 504 ms,
      `executionTime` 3 192 ms, worker `o1hx32s8sy1cn2`. Its own log:
      `create container` 13:42:43Z → `start container` +1.0 s → entry.sh +2.3 s
      → ComfyUI `Starting server` +10.1 s → handler `API is reachable` and
      `got prompt` +10.2 s. Against C.11.01's genuine pre-rebuild boot of 53 334
      ms that is 43 s FASTER, not 20 s slower — even with the video packs, the
      Lightricks pack and 1149 classes in the image. One image serves both
      endpoints (D-V2 stands). Probe script `coldstart-probe.mjs` reads the
      timeline with `runpod-worker-log.mjs`._
- [x] **V.01.09** ComfyUI's own validator, in CI, for $0: after the smoke test,
      start ComfyUI `--cpu --listen` inside the built image, create a shadow
      volume of ZERO-BYTE files named exactly per the manifest `destPath`s
      (ComfyUI validation checks combo membership by filename and never opens
      the file), `POST /prompt` every rendered `motion` graph (golden fixtures
      from V.08, both `speed_mode`s, every `mode`), assert HTTP 200 with empty
      `node_errors`, then `POST /queue {"clear":true}` + `POST /interrupt`
      before anything executes. A graph that fails validation fails the build.
      This is the proof that replaces a live clip for every mode not in the V.11
      matrix. _**Done 2026-09-13 — in the RunPod build, which is the CI here
      (Actions is not the build path).** `smoke-test.sh` now shadows the volume
      (42 zero-byte files at every manifest `destPath`, `extra_model_paths`
      pointed at the shadow root) BEFORE ComfyUI boots, and after the class
      check runs `validate-goldens.py`, which `POST /prompt`s every golden
      fixture — all 17 motion goldens (every `mode`, both `speed_mode`s) plus
      chroma, 18 in all — and clears + interrupts each accepted prompt. Build
      `6bbdae22` (commit `f73b8998d`, image tag `…:f73b8998d`) COMPLETED:
      `[validate] 18/18 rendered graphs accepted by ComfyUI's validator`, HTTP
      200 each, `smoke exit 0`; a 400 with `node_errors` exits non-zero and the
      smoke is fatal, so this can fail the build. The first attempt, build
      `055f8d58`, FAILED at the manifest `COPY` because the root `.dockerignore`
      excludes `infra` — that one file is now re-included.
      `validate-goldens.py --self-test` proves the accept/reject/cleanup
      plumbing on a stub server without ComfyUI. The live endpoints still run
      `a5ac70968`; releasing `f73b8998d` is a separate decision. Evidence block
      `## V.01.09`._

## V.02 Volume growth and video model inventory

- [x] **V.02.01** Grow `ax0oj250j3` to 500 GB with
      `runpod-provision.mjs volume update --size-gb 500 --yes` (add the
      subcommand if absent; REST `PATCH /v1/networkvolumes/{id}`; `--dry-run`
      prints the body). Irreversible; requires the user's explicit go in the
      conversation. Record the new size, the resulting monthly cost, and the
      date in the evidence file and in
      `infra/runpod/volumes/desired-state.json`. _Done 2026-09-11 15:12Z: 100 →
      500 GB live (`volume update` subcommand added with grow-only guard +
      tests); evidence `## V.02`; desired-state file created._
- [x] **V.02.02** Add the video rows to
      `infra/runpod/volumes/isis-chroma-models.manifest.json` (HF `revision` =
      the commit SHAs in the facts block, `quantization: "none"`, `sharedBy`
      where applicable, `sizeBytes` from the HF API, `sha256` empty until the
      loader fills it): `wan22-t2v-high-fp16`, `wan22-t2v-low-fp16`,
      `wan22-i2v-high-fp16`, `wan22-i2v-low-fp16` (`diffusion_models/`),
      `wan22-animate-bf16`, `wan21-vace-14b-fp16`, `umt5-xxl-fp16`
      (`text_encoders/`), `wan21-vae` (`vae/`), `clip-vision-h`
      (`clip_vision/`), `wan22-t2v-lightx2v-high`, `wan22-t2v-lightx2v-low`,
      `wan22-i2v-lightx2v-high`, `wan22-i2v-lightx2v-low`,
      `wan22-animate-relight-lora` (`loras/`), `ltx23-22b-dev` (`checkpoints/`),
      `ltx23-spatial-x2`, `ltx23-temporal-x2` (`latent_upscale_models/`),
      `gemma3-12b-it-bf16` (`text_encoders/`), `flashvsr-v11-dmd`,
      `flashvsr-v11-lq-proj`, `flashvsr-v11-tcdecoder`, `flashvsr-v11-vae`
      (`FlashVSR/…` — folder name from V.01.03), `gimmvfi-f`, `gimmvfi-r`,
      `raft-things`, `flowformer-sintel` (`interpolation/gimm-vfi/`),
      `yolov10m-onnx` (`detection/`, from `Wan-AI/Wan2.2-Animate-14B`
      `process_checkpoint/det/`), `vitpose-wholebody-onnx` (`detection/`, repo +
      file + gating confirmed in V.02.03 first). Manifest lint green with the
      500 GB size; quantized-filename patterns extended with `fp4`, `q4`,
      `fpmixed`, `convrot`. _Done 2026-09-12: **31 rows added, 41 total, 354.85
      GB of 500 GB (29.0 % headroom), lint 0 errors 0 warnings**, plus the three
      controlnet_aux rows V.02.03 turned up. `sha256` is filled now, not left
      for the loader: for an HF row the LFS oid **is** the content sha256 (the
      manifest's own note says so), so the pull can be verified against a value
      recorded before it. **Every size and sha256 was re-fetched and diffed
      against the live API** — all 39 HF rows match. Lint gained the folders
      `latent_upscale_models`, `audio_encoders`, `interpolation`, `detection`,
      `FlashVSR-v1.1`, `controlnet_aux`, and the pattern gained `fpmixed`,
      `convrot` and a delimited `q4` (`fp4` was already there); the pattern was
      checked against all 19 real filenames (no false positive on `fp16`/`fp32`)
      and 6 quantized ones. Its two checked-in-manifest tests were repinned to
      the new totals._
- [x] **V.02.03** Verify the two rows not checked today before the pull:
      `JunkyByte/easy_ViTPose` ONNX wholebody file name, size, gating; the
      controlnet*aux DWPose (`yzd-v/DWPose` `dw-ll_ucoco_384.onnx`,
      `yolox_l.onnx`) and Depth Anything V2 checkpoints the pack loads at the
      pinned SHA — add their rows under `controlnet_aux/`. Anonymous HF API;
      record `gated` for each. \_Done 2026-09-12, evidence `## V.02.03`; every
      repo ungated, every size and sha256 from `paths-info` so the manifest can
      be filled before the pull. **Two findings changed the plan:** (1)
      `vitpose-h-wholebody.onnx` is 412,883 B — a weightless ONNX graph whose
      external data lives elsewhere, byte-identical to the official Wan repo's
      `end2end.onnx`, and in that repo the `.onnx` is a **directory of hundreds
      of external-data files**. The row is `vitpose-l-wholebody.onnx`
      (1,234,579,166 B), the largest usable single file; the pack takes the
      filename from a `models/detection` dropdown and hard-codes nothing. (2)
      the controlnet_aux ckpt env var V.01.03 needs is
      `AUX_ANNOTATOR_CKPTS_PATH`, and its layout is
      `<ckpts_dir>/<repo id>/<filename>`, which fixes the three destPaths. Adds
      ~2.98 GB, ~1.5 GB more than the footprint table assumed (it never counted
      the annotators).*
- [x] **V.02.04** Loader-pod pull (C.02.06 recipe; CPU pod in EU-RO-1, no GPU):
      run `runpod-volume-loader.py` on the new rows only (idempotent skip of the
      C.02 rows must be observed in the log). Expect hours for 283 GB; poll, do
      not babysit. Record wall clock, pod cost, and `manifest-result.json`
      summary. _Done 2026-09-12 on the user's explicit go. Pod `689tdcv0qscxgt`,
      CPU-only (`cpu3c`, 2 vCPU) EU-RO-1, rented 12:30:33Z, loader finished
      **13:27:47Z** — **57.2 min wall clock, $0.0572 of pod time**. The estimate
      before the run was $0.25 and the cost table guessed ~$3; the real figure
      is an order of magnitude under the table. `manifest-result.json`: 48 rows
      (42 artifacts + 6 companions), **`failures: 0`**, **16 skipped as already
      correct** — that is the idempotent skip this item asks to observe — and
      **32 downloaded, 288.23 GB in 55.4 min of transfer, 86.7 MB/s**. Volume
      now **42/42 rows, 358.30 GB of 500 GB**. Evidence `## V.02.04 / V.02.05`._
- [x] **V.02.05** Fill `sha256` for every new row; lint green; commit. Then
      delete the loader pod; `pod get` gone; `currentSpendPerHr` 0. Record.
      _Done 2026-09-12. The hashes did not need filling — V.02.02 had already
      taken them from HuggingFace LFS oids **before** any bytes were fetched —
      so this became the stronger check: **every one of the 42 artifacts
      verified against its pre-recorded sha256, 42 matched, 0 mismatched.**
      Verifying against a value written down in advance is worth more than
      filling one in afterwards, which would only ever agree with itself.
      Manifest lint **0 errors 0 warnings** (42 artifacts, 358.30 GB of 500 GB,
      28.3% headroom). Pod deleted; `pod list` → `[]`; `currentSpendPerHr`
      **$0.049**, which is the 500 GB volume alone at $0.07/GB/month and nothing
      else. **A trap for the next person:** the loader keys result rows
      `"<id>:<file>"` and two artifacts carry companion files, so matching on
      the id alone compares a companion's hash to its parent's and reports six
      false mismatches — match on `id:file`._

## V.03 Video endpoint (bounded by design)

> **Before debugging this endpoint, read rule 9 in "Non-negotiable rules".** The
> image-track endpoint burned most of 2026-09-11 on a defect blamed on the
> worker image that was actually a wedged endpoint, fixed by a console re-save.
> The H100 endpoint below will sit in the same EU-RO-1 datacenter on thinner
> supply, so it is the most likely place to repeat the mistake: zero workers in
> every state with a job queued is an endpoint fault, not an image fault, and
> "Low Supply" is not a capacity verdict.

- [x] **V.03.01** Add `comfyui-video` to `desired-state.json` `development`:
      `name: isis-comfyui-video`, `gpuIds` = the exact H100 80 GB id from the
      REST GPU list (record which — SXM vs PCIe), `workersMin 0`,
      `workersMax 1`, `idleTimeout 10`, `executionTimeout 900`,
      `flashBoot     true`, `networkVolumeId ax0oj250j3`,
      `containerDiskInGb 30`, same image digest,
      `registryAuthName oshun-ghcr-pull`, `workerKind worker-comfyui`,
      `endpointIdEnv RUNPOD_COMFYUI_VIDEO_ENDPOINT_ID`, env
      `COMFY_POLLING_MAX_RETRIES=3600`, `COMFY_POLLING_INTERVAL_MS=250`,
      `BUCKET_ENDPOINT_URL`/`BUCKET_ACCESS_KEY_ID`/`BUCKET_SECRET_ACCESS_KEY`
      referenced by env NAME only (the provision script injects values from the
      environment; never in the JSON). Validator covers the new entry and
      rejects `executionTimeout > 900` for any endpoint. _Done 2026-09-12 —
      **and the GPU premise needs the user's eye.** Live `gpuPools` (verified
      2026-09-12) returns AMPERE_16, AMPERE_24, ADA_24, BLACKWELL_32,
      ADA_32_PRO, AMPERE_48, ADA_48_PRO, AMPERE_80, ADA_80_PRO, BLACKWELL_96,
      HOPPER_141, BLACKWELL_180, BLACKWELL_288: **there is no 80 GB Hopper
      pool**, so the chroma endpoint's pool-id form cannot express "H100 80 GB".
      The entry uses the exact `gpuTypes` ids `NVIDIA H100 80GB HBM3` (SXM) and
      `NVIDIA H100 PCIe`, both 80 GB, with `NVIDIA H100 NVL` (94 GB) excluded as
      a different price class; the documented fallback is HOPPER_141 (H200),
      never a smaller card, because a 28.6 GB fp16 expert would OOM after the
      load was billed. V.03.04 must read the console back after creation — the
      console is the authority on placement (rule 9) and REST echoes a stale
      list. The validator gained `validateSharedEndpointBounds`, applied to
      EVERY endpoint in the file: workersMin 0, workersMax 1, flashBoot,
      idleTimeout ≤ 15 s, the seeded volume, the worker kind, a global 900 s
      ceiling, and a refusal of any `SECRET|TOKEN|PASSWORD|ACCESS_KEY` value
      written into the JSON. A new test also asserts each endpoint's
      `COMFY_POLLING_MAX_RETRIES ×     INTERVAL_MS` covers its own
      `executionTimeout`, so the worker never gives up on ComfyUI before RunPod
      gives up on the worker. 14 validator tests pass; the checked-in file is 0
      errors._
- [x] **V.03.02** Inventory
      `infra/runpod/endpoints/inventory/comfyui-video.json` (schemaVersion 2):
      `handlerKind worker-comfyui`, `modelFlavor     none-volume-backed`,
      `workflowIds` = the V.08 ids, `requiredModels` = the V.02.02 ids,
      `requiredCustomNodeClasses` from V.01.05, `bakedModelArtifacts: []`. Mark
      `comfyui-vace.json`, `comfyui-ltx2.json`, `comfyui-flagship-video.json`
      `status: "retired-never-published"` (do not delete). _Done 2026-09-12.
      `comfyui-video.json` carries 11 workflow ids, 32 models (derived from the
      manifest minus `comfyui-chroma`'s `requiredModels`, plus
      `birefnet-hr-matting`, which is genuinely shared — `birefnet-video-matte`
      runs the same model per frame), 16 pack classes and 31 core classes. Every
      pack class is the **registered key** read from that pack's own
      `NODE_CLASS_MAPPINGS` at its pinned SHA, which is not always the class
      name (`VHS_LoadVideo` is the class `LoadVideoUpload`). `endpointId` is
      `null` and the notes say why: neither the endpoint nor the V.08 graphs
      exist, so this is a contract to build against, not a record of what runs.
      The three stale inventories are marked `retired-never-published` with the
      reason (baked flavor image never published, quantized weights) rather than
      deleted._
- [x] **V.03.03** `warm-cold-policy.json`: class `interactive-video-single`,
      every profile resolves `workersMax 1`; spec. _Done 2026-09-12. Warm 15 s,
      balanced 10 s, cold 5 s — **shorter than the image class at every
      profile**, deliberately: an idle H100 costs about four times an idle 4090
      and holding one warm cannot pay for itself when a 28 GB checkpoint load
      dominates the run. Every profile also stays inside the 15 s idle bound the
      endpoint validator enforces, so any of them can be applied to the live
      endpoint without breaking its own bounds — the first draft had warm at 20
      s and the check caught it. Two specs: the class's profiles, and that every
      endpoint assignment names a class and tier that exist._
- [x] **V.03.04** Create the endpoint (`endpoint create --yes`), drift check
      green, health at rest 0/0/0, id recorded in evidence + env recipe. _**GPU
      settled 2026-09-12 (user approved), endpoint blocked on a template, not on
      hardware.** The approved tier chain is 96 GB → 80 GB → 141 GB, and
      `desired-state.json` now carries
      `NVIDIA RTX PRO 6000 Blackwell Server Edition,NVIDIA A100 80GB PCIe,NVIDIA H200`
      — every one clears the **70.53 GB** peak computed from the manifest
      (`ltx23-av` = 46.15 GB LTX + 24.38 GB Gemma; `wan22-i2v` both experts +
      umt5 + vae + clip = 70.04; `wan22-t2v` both experts = 68.77), so none can
      OOM after the load is billed. Every 48 GB card was rejected for that
      reason: A40 at $1.22/h and L40S at $1.75/h cannot hold LTX-2.3 at all, and
      `wan22-animate` at 47.43 GB sits on the edge of 48 with nothing left for
      activations. Across the eight-clip V.11 matrix the price spread between
      the surviving options is about **$0.30**, so headroom is worth more than
      the cheapest rate. Desired-state validator green, 16 endpoint-config tests
      pass. **What blocks creation:** a RunPod template backs exactly one
      endpoint (`This template is already bound to an endpoint`), the chroma
      endpoint's git-integration template `j1gzx4nccu` is unreadable and
      uncloneable through either API (`404 template not found`), and
      `template create` rightly refuses an image that is not digest-pinned —
      which a git-integration build never is (C.01.09). The endpoint therefore
      has to be created in the **console**, attaching the same git build to a
      second endpoint. Detail and two corrections to V.03.01's GPU premise in
      the evidence file._ _**Created 2026-09-12: `2lezocymx2rgot`**
      (`isis-comfyui-video`, template `qcxiqduk01`), via the console's Deploy
      from a GitHub repository flow on branch `runpod-comfyui-slim`. Seven cards
      live (RTX PRO 6000 Blackwell Server/Workstation/Max-Q, H100 PCIe/80GB
      HBM3/NVL, H200), workersMin 0 / Max 1, idle 10 s, execution 900 000 ms,
      FlashBoot on, volume `ax0oj250j3`, queue-delay 4 s, disk 30 GB. **Drift
      check green on BOTH endpoints**; at rest `currentSpendPerHr` $0.049, the
      volume alone; health showed `idle: 1, ready: 1`, so the git build boots.
      **The finding of the day, and it came from the user: GPU supply labels are
      GLOBAL until a network volume is attached.** Selecting the volume locked
      the datacenter to EU-RO-1 and the same tiers re-read 96 GB High → **Low
      Supply**, 80 GB High → **Unavailable**, 141 GB Medium → **Unavailable**.
      The three-deep fallback is a chain of one in the region the volume lives
      in; all three stay enabled because "Unavailable" is point-in-time, but
      plan on 96 GB or nothing, and never size an endpoint from the pre-volume
      labels. **Two corrections:** the console's 80 GB serverless tier is
      **H100** ($4.79), not A100 80GB PCIe ($2.72) — A100 is not offered to
      serverless here, so the middle rung of my own recommendation was mispriced
      (the verdict is unchanged: 96 GB is cheaper AND larger). And GraphQL's
      `gpuIds` pool string is lossy in both directions — it lists
      `BLACKWELL_288` that REST says is not enabled. **A defect fixed on the
      way:** `runpod-endpoint-drift-check.mjs` compared against that pool
      string, so it reported drift on a correct endpoint and could not have seen
      a wrong card swapped inside a matching pool; it now reads the concrete
      card list from REST when desired-state is written in cards, and warns
      rather than silently falling back. 11 tests pass._
- [x] **V.03.05** Kill switch and GPU fallback documented for this endpoint
      (workers-max → 0; if H100 stock is absent in EU-RO-1 at run time the job
      sits `IN_QUEUE` and is cancelled by the API timeout — document, do not
      auto-fallback to a smaller GPU that would OOM on fp16 14B). _Done
      2026-09-12, runbook §2f, against the live endpoint `2lezocymx2rgot`. The
      no-fallback rule is stated with its reason — a 28.6 GB fp16 expert that
      OOMs has already been billed for the load, so falling back to a 48 GB card
      converts a free wait into a charge for nothing — and the endpoint enables
      only cards that clear the 70.53 GB peak, so the rule is enforced by
      configuration rather than by hoping. The waiting half is tied to C.12.17:
      `IN_QUEUE` is unbilled (`delayTime` is not GPU time), so the cost of
      waiting is wall clock, and what ends it is the queue/boot allowance, after
      which the job is cancelled as retryable **because** nothing was spent.
      **Two measured additions the item did not anticipate.** (1) `/run` keeps
      answering `409 ENDPOINT_PAUSED` for ~30 s after `workersMax` is raised
      again, while REST already reports the new value — propagation, not the
      C.12.12 wedge, and worth knowing before anyone debugs it. A queued job
      also outlives the client: the runner's 15-minute cap abandons the wait,
      not the job, so read it back by id rather than submitting a second one.
      (2) **Supply in EU-RO-1 is the real constraint and the console hides it
      until the volume is attached** — the same three tiers read 96 GB High →
      **Low**, 80 GB High → **Unavailable**, 141 GB Medium → **Unavailable** the
      moment `isis-chroma-models` was selected. The documented planning
      assumption is therefore 96 GB or a wait, with all three left enabled
      because "Unavailable" is point-in-time._

## V.04 Video cost control (green before the first dashboard clip)

- [x] **V.04.01** Second ledger key in `runpod-cost-ledger.service.ts`:
      `isis:runpod:cost:video:<YYYY-MM-DD>` with its own budget
      (`ISIS_RUNPOD_VIDEO_DAILY_BUDGET_USD`, default 6.00) and rate
      (`ISIS_COST_RATE_RUNPOD_VIDEO_USD_PER_SECOND`); the executor picks the
      ledger by the workflow's category (`motion` → video). Fail closed. Specs:
      key selection, independent budgets, Redis-down path. _Done 2026-09-12.
      `CostLedgerKind` + a per-kind env table; `ledgerKindForCategory` is the
      ONE rule both the submit gate and the executor's record path call, so a
      job cannot be checked against one budget and recorded against the other.
      `getRunPodCostLedger` caches per kind, so a missing video rate throws for
      video only and leaves image renders running. The submit gate groups a
      batch by ledger and checks each against its own budget instead of summing
      them — a mixed batch was the hole. Snapshots and alarms carry the ledger
      name (V.04.04's second half). 5 new specs: independent keys and budgets
      (an exhausted $6 video day still admits an image job), the Redis-down
      refusal, the rate-missing constructor error naming the right env var, and
      the alarm payload._
- [x] **V.04.02** Per-job video caps in the executor (fail loud with the field):
      Wan `length ≤ 121` frames and `4n+1`, `width*height ≤ 1280*720`, total
      steps `≤ 40`, `batch_size = 1`; LTX `frames ≤ 193` and `8n+1`,
      `width*height ≤ 1920*1088` and multiples of 32, `steps ≤ 40`; Animate
      driving video `≤ 240` frames; VACE / matte / track / VFI / VSR input
      `≤ 241` frames; FlashVSR output `≤ 1920*1080`; GIMM output `fps ≤ 60`.
      Table lives in one module (`motion-caps.ts`) that the dashboard also reads
      for its estimate. Spec per cap. _Done 2026-09-12:
      `libs/isis/workflows/src/motion-caps.ts`, dependency-free (no `node:*`, no
      catalog I/O) so the browser bundle can import it — mapped for the
      dashboard as `@isis/workflows/motion-caps` in both its tsconfig and its
      Vite aliases, by file, because the library index pulls in filesystem
      readers. `checkMotionCaps` returns every broken cap at once, each naming
      the input field, so one refusal tells the caller everything to fix; the
      executor calls it on the REQUESTED inputs before the graph is rendered
      (field names are what a caller can act on) and the rendered-graph caps
      still run after. `snapMotionFrames` gives the dashboard a slider that can
      only produce a legal count. 16 specs, one per cap plus the contract._
- [x] **V.04.03** `estimated_cost_usd` for video is computed, not typed: the
      catalog carries `estimated_seconds_per_megapixel_frame` per workflow
      (calibrated in V.11.05) and the API multiplies by frames × megapixels ×
      rate; the pre-submit refusal uses this number. Spec with the V.11 fixtures
      once measured; until then the sticker table above seeds it and the field
      is labelled `calibration: "sticker"`. _`motion-cost.ts`:
      `rate × frames × megapixels × usdPerSecond`, plus the cold start, because
      a serverless job pays for its boot. All nine motion workflows now carry a
      rate, seeded as `estimated_time_seconds` over their own reference job —
      and a spec re-derives each one and fails if the headline and the rate ever
      diverge, which is what would happen the first time somebody edits
      `estimated_time_seconds` alone._ _**Every rate is
      `cost_calibration: "sticker"` and says so in its own file**, with a
      `cost_calibration_note` reading "NOT measured on a GPU".
      `estimateMotionCost` returns the calibration ALONGSIDE the number, because
      a cost estimate whose provenance is invisible is one that gets trusted for
      budgeting. A spec asserts nothing claims `measured`; V.11.05 is what may
      change that._ _The point of a rate rather than a number: a typed
      `estimated_cost_usd` is correct for exactly one configuration and wrong
      the moment anything changes. A spec pins that 720p is 2.31x the pixels of
      480p and the estimate moves by that factor — a hand-written figure for the
      480p default understates a 720p job by 131%._ _A non-positive input THROWS
      rather than returning 0: a zero estimate is indistinguishable from "free"
      and would sail through every budget gate this number exists to feed.
      `motionCostDelta` subtracts before rounding, so a UI showing "what does
      this toggle cost" is not two rounded totals differenced by the reader._
      _10 specs; 600/600 in `libs/isis/workflows`._
- [x] **V.04.04** Executor `timeoutMs` for `motion` workflows ≤ 900 s
      (desired-state fixture spec); alarm webhooks `runpod.budget.*` carry the
      ledger name (`image` | `video`). _Done 2026-09-12.
      `resolveExecutionTimeoutMs` gives a `motion` workflow the video endpoint's
      900 s and bounds everything else by `min(configured default,     300 s)` —
      a lower default is a tightening and is honoured, but the 300 s default is
      not a decision about video (it predates video) and honouring it would
      abandon clips RunPod is still rendering and still billing.
      `runpod-timeout-coherence.spec.ts` now pins both constants to the
      desired-state file and asserts neither exceeds its endpoint: 7 pass._

## V.05 Video transport (adapter + submission)

- [x] **V.05.01** Confirm RunPod's request payload limits from the live API
      (submit a deliberately oversized `/run` body and record the exact error
      status/text), set `ISIS_RUNPOD_VIDEO_INPUT_INLINE_MAX_BYTES` accordingly
      (default 6 MiB base64), and write the number into the README and this
      file. Not complete until the measured limit is recorded. _Attempted
      2026-09-12 and **INCONCLUSIVE — do not repeat the same way.** The endpoint
      is at `workersMax: 0`, so `/run` answers `409 ENDPOINT_PAUSED`, which
      looked like a free way to probe: no job is created, so no GPU seconds. 10,
      20, 30 and 50 MiB all returned 409. **But so did 120 MiB**, and no service
      accepts a 120 MiB body — so the pause check runs BEFORE the size check and
      every probe was measuring the pause. Against a nonexistent endpoint id, 20
      MiB returns `404 endpoint not found` rather than 413, so the check is not
      at the edge either. Measuring it for real needs `workersMax` ≥ 1, and an
      accepted oversized body would then queue a real job on a real GPU — a
      small spend, not a free one, and it needs the user's go. The threshold
      ships **conservative rather than measured**: 6 MiB of base64, under the
      documented 10 MB, with S3 above it. Wrong in that direction costs an
      unnecessary round trip; wrong the other way costs a rejected job after the
      upload._ _**MEASURED 2026-09-12 and the threshold is now justified.** With
      `workersMax 1` the size check is reachable, and RunPod states the limit in
      its own words: `400 bad request: body: exceeded max body size of 10MiB`.
      Probed DESCENDING against the live video endpoint so the oversized
      requests were free — no job exists to bill: **120 / 60 / 30 / 20 / 16 / 12
      MiB all rejected, 10.00 MiB accepted**. The one accepted request was
      cancelled while still `IN_QUEUE` (verified `CANCELLED`, no `delayTime` or
      `executionTime`), so the measurement cost nothing. **The measurement
      exposed a real defect, which is the more valuable half.** The 6 MiB
      threshold is enforced PER INPUT, but RunPod's limit is on the whole BODY —
      and `wan22-animate` carries `reference_image`, `driving_video` and
      `character_mask_video`, so three payloads each legally under 6 MiB
      assemble an 18 MiB body that is rejected outright, after the API has
      decoded, sniffed and buffered every one of them. Added
      `DEFAULT_INLINE_BODY_MAX_BYTES` = 8 MiB (2 MiB of the measured 10 left for
      the graph and JSON wrapper), enforced as a running total while inputs are
      lifted, so the payload that would overflow is routed to the volume or
      refused with the BUDGET reason rather than the per-input one. It spans
      BOTH lifts: `liftInlineImages` runs first on the same `input.images[]`
      channel, so its bytes are passed forward as `alreadyInlinedBytes` — a
      budget that saw only half the body would have been worse than none. It
      also floors at `maxInlineBytes`, so a caller who deliberately raises the
      per-input ceiling for one large payload is not silently overruled (an
      existing spec caught that). 6 MiB per input is unchanged and now has a
      measurement behind it. Specs: 5 new; `worker-comfyui-submission` +
      `media-input-lifting` 42 passed; suites back at the pre-existing 11
      `executor.spec.ts` failures with 515 passing._
- [x] **V.05.02** `worker-comfyui-submission.ts`: accept `video` inputs
      (`data:video/mp4;base64,…`, `video/webm`, `video/quicktime`; magic-byte
      sniff `ftyp` at offset 4 / EBML `1A45DFA3`; fail loud otherwise) and
      `audio` inputs (`audio/wav`, `audio/mpeg`, `audio/flac`). Below the
      threshold → `input.images[]` with a deterministic filename that the
      `LoadVideo`/`LoadAudio` node references; above → V.05.03 path. Spec both
      branches + bad magic. _Done 2026-09-12. `liftInlineMedia` sniffs **decoded
      bytes**, not a base64 prefix — an MP4 is `ftyp` at byte offset 4, which
      lands mid-quantum in base64 and has no stable text prefix, so the image
      sniffer's approach cannot be reused. mp4/mov/webm/mkv and wav/mp3/flac,
      with webm and mkv separated by DocType since they share a header. The
      declared mime is never trusted. Four refusals before any GPU second:
      unrecognised bytes, audio in a video input (and the reverse), a mime
      outside `accept`, and over-ceiling payloads, which name the V.05.03 path
      instead of quietly posting a 50 MB body. **A latent bug fell out:** the
      existing `RAW_BASE64_RE = /^[A-Za-z0-9+/=\s]{64,}$/` throws
      `RangeError: Maximum call stack size exceeded` above ~8 MB (measured: 4 MB
      fine, 8 MB fatal) — survivable for stills, certain for video, and a much
      worse failure than a refusal since it is not a
      `WorkerComfyUiSubmissionError`. Replaced by a bounded head match, O(64) at
      any length; the image path shares the fix. 16 specs; `src/workflows/`
      baseline unchanged at 13 failed / 143 passed._
- [x] **V.05.03** `scripts/isis/runpod-volume-s3-put.mjs` (C.02.09, now
      required) as a library + CLI: SigV4 `PUT` to
      `s3api-eu-ro-1.runpod.io/<volumeId>/inputs/<jobId>/<name>`, multipart
      above 100 MiB, sha256 verified by a `HEAD` afterwards; the submission
      rewrites the `LoadVideo.inputs.file` to `volume/<jobId>/<name>`. A
      retention sweeper deletes `inputs/<jobId>/` and `outputs/<jobId>/` older
      than 7 days (cron in the API, dry-run flag). Spec with a fake S3. _**The
      signer is cross-checked against botocore, not against itself.** A
      hand-rolled SigV4 that agrees with its own test is worth nothing, so the
      eight known-answer `Authorization` headers in
      `runpod-volume-s3-put.test.mjs` were produced by botocore 1.42.97 — a
      different implementation by a different vendor — with its clock pinned;
      the generator is committed as
      `scripts/isis/fixtures/sigv4-vectors-botocore.py` so they can be
      regenerated. All eight match exactly, covering a body-bearing PUT, a
      ranged GET, HEAD, DELETE, a three-parameter list, multipart create and
      part upload (query strings that must be canonicalized and sorted), and a
      key containing a space, a `+` and parentheses — the characters
      `encodeURIComponent` gets wrong for S3, which is the bug that would have
      shipped._ _SigV4 is hand-rolled rather than taken from
      `@aws-sdk/client-s3` because the file has to run as a bare script from the
      repo root, where the SDK is not resolvable (checked:
      `ERR_MODULE_NOT_FOUND`), and RunPod's S3 API is a narrow subset that does
      not need a 3 MB client._ _The rest is exercised against a REAL `node:http`
      server standing in for S3, so bodies, content hashes and multipart
      sequencing go over a socket rather than past a stubbed `fetch`. The fake
      verifies independently what it can: a well-formed SigV4 header over the
      expected signed headers, and that `x-amz-content-sha256` is the true hash
      of the body it received. 26/26 green. Three failure modes are pinned
      because each one loses data quietly: a failed part ABORTS the upload (an
      abandoned multipart keeps billing parts on a fixed-size volume), a
      completion that returns **HTTP 200 with an `<Error>` body** — which S3
      really does — is treated as the failure it is, and `putFile` re-HEADs and
      refuses when the stored size disagrees with the file, because a truncated
      input clip is a job that burns GPU minutes producing garbage._ _The
      sweeper refuses any prefix outside `inputs/`/`outputs/` (the seeded model
      weights are on the same volume and took hours to put there) and SKIPS an
      object whose `LastModified` it cannot parse rather than deleting it —
      deleting because a date could not be read is how a volume gets emptied._
      _Submission half: `liftInlineMedia` now takes a `volumeJobId`. With one,
      media over the inline ceiling is rewritten to `volume/<jobId>/<name>` and
      the decoded bytes are returned in `prepared.volumeUploads` for the caller
      to PUT; without one it still throws, because referencing a volume path
      nothing will ever upload to is worse than refusing. The function stays
      synchronous and pure — it renders a graph, it does not do I/O. Spec'd that
      the clip does NOT also ride `input.images[]` (sending 8 MiB twice is the
      bug the path exists to avoid), that a clip under the ceiling stays inline
      even when a job id is available, that the bytes are still sniffed before
      routing (an oversized PNG is refused, not uploaded), and that the S3 key
      and the worker reference name the same file._ _Cron half:
      `volume-retention-sweeper.service.ts`, started from `index.ts` and drained
      on SIGTERM/SIGINT. **Off unless enabled, and a dry run even then** —
      `ISIS_VOLUME_RETENTION_DRY_RUN` needs an explicit `false`/`0`/`no`/`off`,
      and the dry-run log line is identical to the real one so the rehearsal
      shows exactly what will happen. The first sweep is on the interval, never
      at boot: a startup that also deletes storage is hard to interrupt when it
      is the wrong startup. A failing sweep is logged and the schedule survives.
      11/11 green on fake timers. The S3 client is loaded at runtime (it is a
      standalone script, not a build input of the app); enabled-but-unloadable
      logs an error and stays off rather than looking like a volume with nothing
      old on it — verified by running the loader under tsx both configured
      (loads) and unconfigured (throws naming the three missing variables).
      Documented in runbook §2d._
- [x] **V.05.04** `runpod-adapter.ts` `mapRunPodOutput`: entries whose
      `filename` ends in `.mp4|.webm|.mkv` map to
      `JobOutput{kind:'video',     mimeType, url|dataBase64}`; sniff magic
      (ftyp/EBML) not the extension; `s3_url` from the volume S3 endpoint is
      re-signed by the API for the browser (the RunPod S3 URL is not public).
      Spec: mp4 base64, webm s3*url, alpha webm, mixed image+video result (the
      `wan22-t2v` graph also saves the last frame PNG). \_Done 2026-09-12.
      `sniffBase64VideoMime` decodes and reads real bytes — `ftyp` at offset 4
      for mp4/mov (with the `qt` brand separating QuickTime), and the shared
      EBML header for webm/mkv, split by DocType. **The filename is not
      authoritative and a spec pins it in both directions**: a clip named `.png`
      maps as video, a still named `.mp4` maps as image. The `s3_url` branch has
      no bytes to sniff, so it falls back to the extension — but that name is
      the worker's own `filename_prefix` plus the format ComfyUI wrote, not
      anything a caller supplied — and tags the output `requiresSigning`,
      because the volume's S3 URL is not public and the API re-signs it before a
      browser sees it (V.05.05). The "not an image" error now names both
      possibilities. 11 specs in the file, 192 in the provider suite, all
      green.*
- [x] **V.05.05** Output fetch: when the worker returns `s3_url`, the API
      streams the object through SigV4 into the C.07.01 store
      (MinIO/`ISIS_OUTPUT_DIR`) and persists `durationMs`, `fps`, `frames`,
      `width`, `height`, `hasAudio`, `codec` (probe with `ffprobe` if present,
      else parse the mp4 `mvhd`/`tkhd` boxes — implement the parser, no guess)
      alongside C.07.02's fields. Spec on both probes. _**The parser is done**
      (`mp4-probe.ts`); the S3 streaming half is not, so this stays `[ ]`.
      `probeMp4` walks the box tree — `mvhd` for duration, the video `trak`'s
      `tkhd` for size (16.16 fixed point), `mdhd` for the track clock, and
      `stts`, a run-length table whose sample counts are summed for the frame
      count. `hasAudio` comes from a `soun` handler actually being present.
      **Cross-checked against ffmpeg and ffprobe, not just against itself**: a
      real 17-frame 64x64 clip with audio is committed as a fixture and every
      expectation is ffprobe's reading of it, matching exactly on all six
      fields. Checked across 5/9/17/33/81-frame clips too, all exact. **One
      honest caveat is documented**: `fps` is the AVERAGE over the track (frames
      ÷ track duration), not the nominal header rate. They agreed on every
      ordinary clip, but a track truncated by `-shortest` muxing gave nominal 16
      / average 12.8 — and the average is the right answer to "what did this
      file actually contain". WebM returns null rather than a guess: it is EBML,
      a different container. The parser omits what it cannot read instead of
      inventing it — a clip with a duration but no frame table reports the
      duration and no fps. Fuzzed against every truncation of both a synthetic
      and a real file: no throw._ _**The S3 half is now done too.**
      `persistJobOutputs` takes an injected `fetchS3`; in production it is
      resolved lazily from `runpod-volume-s3-put.mjs` (V.05.03) and **refuses to
      sign a request for any URL not under the configured endpoint and bucket**
      — an output URL comes from the worker, and signing arbitrary hosts would
      make this a credentialed fetcher for whatever a worker points at. The
      bytes land in the same C.07.01 store as everything else, so the browser
      gets one kind of URL however the worker returned it. A failed fetch keeps
      the S3 URL and records `s3FetchError`: the render is already paid for, and
      dropping it because S3 blinked would destroy the only copy._ _Two
      corrections found while wiring it, both drift the projection spec was
      supposed to catch and did not. (1) An `s3_url` output arrives from the
      adapter already carrying `source`/`encoding`/`kind`/`requiresSigning`,
      which are spread through verbatim and reach the dashboard — none were
      declared on `JobOutputFileFacts`. Declared now, and the projection spec
      gained a case that runs the ADAPTER's real output shape through, not just
      fixtures with no metadata of their own. (2) `requiresSigning: true`
      survived onto the persisted local URL, telling every consumer the API's
      own URL was not loadable; it is dropped on a successful fetch and
      deliberately KEPT when the fetch failed, because then it is true._
      _`codec` was the one field of the seven that the parser did not read. It
      now comes from the video track's `stsd` sample entry, reported as the raw
      4cc — `hvc1` vs `hev1` is the distinction that decides whether Safari
      plays the file, so mapping both to "h265" would throw away the useful
      half. ffprobe on the committed fixture says `codec_tag_string=avc1`; the
      parser says `avc1`. Added to the client type and the dist rebuilt with
      `npx tsup`._ _24/24 on the persistence and projection specs, 14/14 on the
      probe; `npx tsc --noEmit` on the app clean._
- [x] **V.05.06** Adversarial pass over V.05 changes; evidence block. _Scope:
      `mp4-probe.ts`, `output-persistence.service.ts`,
      `volume-retention-sweeper.service.ts`, `worker-comfyui-submission.ts`,
      `routes/outputs.ts`, `scripts/isis/runpod-volume-s3-put.mjs`. The
      confession grep returned two hits, both the prose phrase "in production"
      inside honest comments, no action. `Math.random()`: none. Every `catch`
      read in context — four of them, none fabricating success: `assertOk`
      catches only the error-detail read and still throws, the multipart catch
      aborts the upload and rethrows, `sweepOnce` returns a distinct `{error}`
      shape that is logged and spec'd, and the sweeper's loader catch logs and
      declines to start. Every exported function's parameters checked for being
      accepted and ignored: none are._ _**Two real findings, both fixed.** (1)
      `parseTkhdSize` read the tkhd version byte and discarded it with `void v`
      — the behaviour was right (width/height are the last eight bytes of the
      box in both versions) but the dead read made it look like it branched on
      something it did not. The read is gone, the reason is in the doc comment,
      and a version-1 `tkhd` — 12 bytes longer, with 64-bit times — is now a
      test case, so the claim is measured rather than asserted. (2)
      `signRequest` accepts a `sessionToken` that nothing in the file supplies
      and `resolveConfig` has no env var for; it is honoured when passed, so not
      a stub, but it now says so, because the failure mode was someone setting
      an env var that is never read._ _Re-run after the fixes: 26/26 on the S3
      client, 13/13 on the probe, 23/23 on media lifting, 24/24 on persistence
      and projection._

## V.06 Catalog schema and executor for video

- [x] **V.06.01** Catalog input types `video` and `audio` (with `max_bytes`,
      `max_frames`, `accept`) in the schema, `input-profile-lint.ts`,
      `catalog-renderer.ts` (the renderer already lifts `image` inputs into
      `LoadImage`; do the same for `LoadVideo`/`LoadAudio` and for
      `VHS_LoadVideo` when a graph uses VHS). Output-contract lint: `video`
      outputs must declare `format`, `codec`, `fps_source`, `audio` (bool),
      `alpha` (bool). Specs. _Partly done 2026-09-12 — **stays `[ ]` for the
      renderer half.** Landed: `VideoInputSchema`/`AudioInputSchema` with
      `max_bytes` (which decides inline vs volume transport), `max_frames` and
      `accept`; both fallbacks in `input-profile-lint`; `fps_source` and `alpha`
      on `OutputSpecSchema`; and `lintVideoOutputContract`, a separate exported
      function rather than a schema refinement **on purpose** — a refinement
      would have failed every existing `flagship/` and `video/` workflow, which
      D-V3 says to leave untouched, so the caller scopes it to `motion`. 6
      specs, including that `audio: false` is an answer and absence is not.
      **Still open: the renderer lifting `LoadVideo`/`LoadAudio`/
      `VHS_LoadVideo` inputs** — that is the same seam as V.05.02 (the
      submission's magic-byte sniff and inline/volume split) and lands with it._
      _**Closed 2026-09-12 with V.05.02/V.05.03.** The lift is in
      `liftInlineMedia`, keyed off the catalog input's declared `type` — there
      is no per-node-class branch and there should not be: `LoadVideo`,
      `LoadAudio` and `VHS_LoadVideo` all take the filename the worker wrote, so
      a node-class list would only be a second place to forget to update when a
      pack adds a loader. Spec'd end to end through
      `prepareWorkerComfyUiSubmission` on a graph using `VHS_LoadVideo` and
      `LoadAudio` together, asserting both land in `input.images[]` and that the
      audio travelled as audio — the mime in the data URL is not trusted, the
      bytes decided._ _`max_bytes` and `max_frames` are now ENFORCED, not just
      declared. They were documented in the schema as bounds "enforced before a
      byte is uploaded" and nothing read them. `max_bytes` is the workflow's own
      ceiling and is a refusal (`MEDIA_EXCEEDS_INPUT_LIMIT`); the transport
      ceiling is a separate number that only decides whether the bytes ride the
      request or the volume, and the spec pins a case that is over one and under
      the other in each direction. `max_frames` is counted from the clip's own
      box tree via `probeMp4`, not taken from the caller — a too-long clip that
      gets through costs GPU minutes before it fails, if it fails at all;
      measured against the real 17-frame ffmpeg fixture. A WebM passes
      unmeasured and says so: it is EBML, `probeMp4` returns null rather than
      guessing, and the cap falls back to the graph's own frame inputs. 23/23._
- [x] **V.06.02** Register `motion` in `WORKER_COMFYUI_ONLY_CATEGORIES`
      (`executor.ts:3323`) and in `chroma-catalog-routing.spec.ts` (rename the
      spec's scope if needed); generation types `video-to-video`,
      `video-upscale`, `frame-interpolation`, `video-segmentation`,
      `video-matting` added to the job-envelope routing manifest;
      `text-to-video` and `image-to-video` route to the `motion` ids under the
      gate. Spec. _Done 2026-09-12: `WORKER_COMFYUI_ONLY_CATEGORIES` is now
      `{chroma, motion}`, and the five new generation types plus their
      `ISIS_GENERATION_TYPE_MANIFEST` entries are in the job envelope —
      `video-segmentation` and `video-matting` declare `multiple: true` because
      they return a mask sequence beside the cut-out. The checked-in `src/*.js`
      / `src/*.d.ts` shadows were regenerated (they shadow the `.ts` at runtime;
      see the landmine note), 28 envelope tests pass, and the resolver's
      routing-completeness validation now covers 23 types._
- [x] **V.06.03** Endpoint routing: the executor sends `motion` workflows to
      `RUNPOD_COMFYUI_VIDEO_ENDPOINT_ID` and everything else to
      `RUNPOD_COMFYUI_ENDPOINT_ID` (one adapter instance per endpoint in
      `comfyui.service.ts`; the cost rate follows the endpoint). Spec: a
      `chroma` job never reaches the video endpoint and vice versa. _Done
      2026-09-12. A second `RunPodAdapter` bound to the video endpoint, not a
      per-request endpoint override: an adapter owns its endpoint's queue stats,
      circuit breaker and SLO snapshots, and mixing two endpoints' telemetry in
      one would make both meaningless. The executor puts the catalog category in
      the provider metadata (one lookup drives both the endpoint and the ledger)
      and `comfyui.service` routes on it. A `motion` submit with no video
      endpoint configured **fails loud** — falling back to the image endpoint
      would send a 28 GB expert to a 24 GB card and bill the failure. An absent
      category is treated as image, the safe direction: the image endpoint
      refuses a graph whose classes it lacks, while the reverse would quietly
      bill H100 seconds for a Chroma render. 5 specs, plus one pinning the
      ledger and the endpoint to the same category source._
- [x] **V.06.04** Two-expert rendering helper for Wan 2.2 A14B: the renderer
      emits `UNETLoader(high)` → `ModelSamplingSD3(shift)` → optional
      `LoraLoaderModelOnly(lightx2v high)` →
      `KSamplerAdvanced(steps 0..k,     add_noise, return_with_leftover_noise)`
      → `UNETLoader(low)` → … → `KSamplerAdvanced(k..N, no add_noise)` from one
      `steps`/`boundary_ratio` pair; `speed_mode=lightx2v_4step` forces
      `steps=4, k=2, cfg=1.0` on both experts. Golden fixture for the rendered
      graph per mode. _`wan-speed-mode.ts`, a post-render transform:
      `ComfySwitchNode` is how ComfyUI's template expresses the choice and a
      bare `/prompt` graph has no equivalent, so the switch becomes "these nodes
      exist" or "they do not". The renderer is a template substituter and cannot
      add nodes, so the choice is made on the RENDERED graph and the workflow
      declares it in `post_render.wan_speed_mode`._ _Golden fixture per mode on
      both A14B graphs — `wan22-t2v` and now `wan22-i2v`, each with a
      `.480p_landscape` and a `.lightx2v_4step`. The lightning fixture is
      asserted on the NUMBERS rather than the node count: steps 4 and cfg 1.0 on
      both samplers, and the split as a handover (high runs 0→2, low runs 2→4)._
      _Three things the specs protect. Each expert gets its OWN distilled LoRA
      and the pair is the **I2V** one — the two models have different LoRAs and
      crossing them is a silent quality loss, not an error. The splice order is
      `UNETLoader → LoraLoaderModelOnly → ModelSamplingSD3`, the template's own:
      a LoRA applied after the sampling wrapper is simply ignored. And the
      quality path is the SAME OBJECT back, so "not fast" is provably a no-op
      rather than a round trip that might differ._ _The transform throws rather
      than half-applying: a graph with one LoRA instead of two, or the fast step
      count with the quality CFG, renders something nobody asked for and bills
      for it. 14 specs on the transform, 18 on the i2v graph._
- [x] **V.06.05** Job chaining for the product pipeline (still → I2V → VFI →
      VSR): `POST /api/v1/jobs/chain` accepts an ordered list of
      `{workflowId, inputs}` where an input may reference `$prev.outputs[0]`;
      the runner submits step n+1 with the previous output's volume path
      (`outputs/<jobId>/…` is already on the volume — no download/upload round
      trip). One budget check per step. Spec: reference resolution,
      stop-on-failure, cost accumulation. _**A chain is a linked list threaded
      through job metadata, not a new store.** The submitted job carries
      `metadata.chain` with the steps that have not run yet; when the runner
      finishes a job it resolves the next step's `$prev.*` references against
      the outputs it just persisted and submits it. Nothing is persisted that a
      job record does not already persist, the chain's state is visible on
      whichever job you are looking at, and a chain interrupted by a restart
      resumes from the job that is still pending. Decisions live in the pure
      `job-chain.service.ts`; the wiring (budget, submit, recording) is
      `job-chain-advancer.ts`, injected into the runner so the runner's own
      specs stay about claiming and running jobs._ _**One deviation, recorded
      because it changes the request shape**: a step is
      `{workflowId, type, inputs}`, not `{workflowId, inputs}`. A job envelope
      needs a generation type and it cannot be inferred here — the classifier
      that derives one from a catalog entry deliberately excludes the `chroma`
      and `motion` catalogs (they are worker-comfyui-only and not in the general
      resolver, which I confirmed by dumping the routing manifest), so guessing
      would route a video step at the image endpoint: exactly the mistake
      V.06.03 fails loud on._ _Reference syntax is deliberately tiny —
      `$prev.outputs[N]` plus `.url`, `.name`, `.volumeKey` — and substitution
      is whole-string only, because a prompt containing a dollar sign is far
      likelier than a caller wanting interpolation. A NEAR-MISS reference is a
      refusal, not a passthrough: `$prev.output[0]` handed to a workflow as a
      filename either fails on the GPU after being billed or succeeds against
      some unrelated file. The guard is `/^\$prev\b/`, so bare `$prev` is caught
      and a prompt word like `$prevalent` is not — both spec'd._
      _`$prev.outputs[0]` resolves to `volume/<jobId>/<name>`, which is the form
      `entry.sh`'s symlink opens, so the bytes are read in place. That required
      V.05.05's fetch to KEEP the volume key: `persistJobOutputs` now stamps
      `volumeKey` when it copies an object off the volume, because the object is
      still there. `volumeKeyOf` returns null rather than guessing for anything
      that is not `<bucket>/{inputs,outputs}/…` — a wrong key sends the next
      step to a file that is not there. The URL is the honest fallback for an
      output that never went through the volume (a dev run with no S3): it
      works, it just costs a round trip._ _One budget check per STEP, against
      the ledger the step's own type bills to — a chain admitted at submit time
      may run for many minutes and the video steps cost several times the still
      that started it; the spec asserts
      `getRunPodCostLedgerForCategory('motion')` is what a video step is weighed
      against. An unreadable ledger is a stop, not permission to spend.
      Stop-on-failure comes free from only advancing after a COMPLETED job, and
      every stop is recorded on the job a person can see
      (`chain-stopped:<code>`) because a chain that stops silently looks exactly
      like one that finished._ _28 specs on the pure module, 7 on the advancer,
      5 on the request schema; 607/607 across the routes and runner;
      `npx tsc --noEmit` clean._
- [x] **V.06.06** Static graph validator (extends C.06.03) against the
      object-info snapshot from V.01.06: every `class_type` exists; every
      required input is present; literal inputs match the declared type and
      range; every link's source output type matches the target input type;
      combo values are in the snapshot's list when the list is non-empty; model
      filenames resolve to a manifest `destPath`; `LoadVideo`/`LoadImage`
      references resolve to a declared input. Runs in the pre-submit path AND as
      a vitest over every `motion` golden fixture (all modes). Adversarial pass;
      evidence block. _**Done 2026-09-13, with the real snapshot.** The two
      checks that were missing landed — literal type + range
      (`LITERAL_TYPE_MISMATCH`, `LITERAL_OUT_OF_RANGE`) and link socket types
      (`LINK_TYPE_MISMATCH`, which was declared but never emitted) — and combo
      membership now reads both declaration forms the 5.10.0 image uses
      (`[[…], {}]` and `["COMBO", {options}]`), with `*_upload` inputs exempt
      because their list is the builder's input dir. The executor reads
      `infra/runpod/endpoints/node-classes/worker-comfyui-5.10.0-video.json`
      (env `ISIS_RUNPOD_NODE_CLASS_SNAPSHOT_FILE` to override; fail-loud
      `SERVICE_UNAVAILABLE` if missing or without a `classes` map) and the
      submission passes it to `validateGraph`, so every check runs pre-submit.
      `graph-validator.snapshot.spec.ts` sweeps all 18 goldens (17 motion +
      chroma) against the snapshot and asserts `issues: []` AND `skipped: []`;
      43/43 across the two validator specs; the two generation-api specs on the
      path 26/26. Adversarial pass found two false positives in the first cut —
      `"FLOAT,INT"` read as a socket type, and `LoadImage`'s `["example.png"]`
      option list — both fixed; evidence block `## V.06.06`._

## V.07 Output persistence for video

      _2026-09-13: the paragraph below is history — the snapshot IS in the repo
      (V.01.06) and V.06.06 above is closed against it._ _Partly done
      2026-09-12 — **stays `[ ]` for the four checks that need the
      object-info snapshot, which is not in the repo yet** (the build HAS run — see
      V.01.06 — but the snapshot it produced is baked at
      `/opt/oshun/build-manifest/object_info.json` INSIDE the image, and getting
      it out needs a running container, which is V.11.01's first worker boot). `graph-validator.ts`
      takes the snapshot as an OPTIONAL input and, when it is absent, RETURNS
      THE LIST OF CHECKS IT COULD NOT RUN rather than passing them — a validator
      that silently "passes" a check with nothing to check against is the exact
      failure this file exists to prevent. With a snapshot all seven run: class
      exists, required inputs present, no undeclared input, combo value in the
      list (skipped when the list is EMPTY, since the worker fills those at
      runtime from what is on disk and asserting membership would fail every
      real model name), and the link's output index inside the source's output
      count._ _Running now, with no snapshot: dangling links, self-links,
      unresolved file references, and `models_required` against the volume
      manifest. Wired into the pre-submit path (`GRAPH_INVALID`) where the
      uploaded file names ARE known, and swept over all **17** motion golden
      fixtures. 16 specs._ _The sweep deliberately does NOT pass
      `declaredFileInputs`: a fixture's file value is whatever the render was
      given (`clip.mp4`), and which names a job actually uploaded is known only
      at submit time — a guessed set would have made the sweep assert a fiction.
      That check is spec'd directly instead._ _`executor.spec.ts` still fails 11
      tests, the same count as before this change and none of them naming
      `GRAPH_INVALID`._

- [x] **V.07.01** C.07.01 store handles `video/*` objects (content-type, range
      requests for the `<video>` element via the API stream, presigned MinIO
      when configured). Spec: HTTP 206 range path. _Done 2026-09-12 for the
      local-disk stream. `parseRangeHeader` handles the three forms a browser
      actually sends — an explicit window, an open-ended offset, and the
      **suffix** form a player uses to find an MP4's `moov` atom when it sits at
      the end of the file. `Accept-Ranges: bytes` goes on **every** response,
      not just ranged ones, because a player decides whether it can seek before
      it asks. An over-long end is clamped (RFC 9110); a start past the end is
      **416 with the real size**, not a quiet full body — a player told 200 will
      believe it got what it asked for. The specs check the exact slice bytes,
      not just the length. Both mime tables gained mkv, mov and flac, which the
      V.05.02/V.05.04 sniffers can produce. 18 specs pass. **S3 presigning is
      not done**: an S3 output already carries a fetchable URL, and the volume's
      own S3 endpoint needs the re-signing V.05.05 covers._
- [x] **V.07.02** Poster frame: extract frame 0 (or the saved last-frame PNG
      when the graph provides one) as `poster.png` next to the video so the
      Outputs grid never decodes mp4s for thumbnails. Spec. \_Done 2026-09-12 —
      **the second way, not the first, and deliberately.** "Extract frame 0"
      needs a video decoder and a slim API image has none; the graphs already
      save the last frame beside the clip under the same `filename_prefix` plus
      `-lastframe`, so the poster is **found, not decoded**. `outputStem`
      reduces both names past ComfyUI's five-digit counter and extension before
      comparing, and only an `image` output whose stem is the clip stem plus
      `-lastframe` qualifies; an unrelated still is never promoted to a
      thumbnail. When there is none, `posterUrl` is **present and null**, so a
      consumer can tell "no poster" from "never looked". The same pass stamps
      the V.05.05 facts read from the clip's own bytes: `durationMs`, `fps`,
      `frames`, `hasAudio`, and `width`/`height` from `tkhd` when the
      image-header reader has nothing to say. 6 specs against the real ffmpeg
      fixture; the service suite is 172 passed.\_
- [x] **V.07.03** Client + OpenAPI for the new output fields (`kind`,
      `durationMs`, `fps`, `frames`, `hasAudio`, `alpha`, `posterUrl`); semantic
      diff reviewed; projection specs. _Client and projection specs done
      2026-09-12; **stays `[ ]` because the OpenAPI half has no target, which is
      itself the finding.** All seven fields are on `JobOutputFileFacts` in
      `libs/isis/client/src/types.ts`, and the dist was rebuilt with `npx tsup`
      (consumers resolve through it — the landmine that has bitten three times).
      **But `openapi/isis/openapi.yaml` models EVERY auto-generated route's 200
      body as `$ref: JsonObject`** — there is no `JobOutput` schema in the
      document at all, so "add the new fields to OpenAPI" has nothing to add
      them to, and the same was already true of C.07.02's image fields. Giving
      the generator real response models is a change that touches every route
      and belongs in its own item, not smuggled in here. In its place, a
      **projection spec** now pins the two sides together directly: it renders a
      real clip through `persistJobOutputs` and asserts every stamped metadata
      key is declared on `JobOutputFileFacts`, and that the video fields appear
      on a clip and not on a still. That is the drift with no other alarm — the
      API can rename a key and every other test still passes while the dashboard
      reads a field that is never populated._ _**Done 2026-09-13 — the OpenAPI
      half had a target after all.** The generator
      (`scripts/isis/generate_generation_api_openapi.mjs`) preserves any
      operation the app's baseline `openapi.yaml` already describes and falls
      back to `JsonObject` only for routes it does not, so typing one response
      touches one route, not every route — the earlier note overstated the blast
      radius. Added `JobOutputFileFacts` (25 properties,
      `additionalProperties: false`, every field with the client's own wording),
      `JobOutputFile` and `JobOutput` to `components.schemas`, and
      `GET /api/v1/jobs/{id}/output`'s 200 now returns `JobOutput`. Semantic
      diff of the regenerated document: 66 paths before and after, 3 schemas
      added, exactly one operation's responses changed, `--check` clean. The
      projection spec now holds THREE sources to one property set — the client
      type, the OpenAPI schema and the API's own `JobOutputFileFacts` in
      `src/types.ts`, which had been missing all twelve video and provenance
      fields (the persistence service stamps them as untyped metadata, so
      nothing had complained); those are declared there now. 7/7 on the spec;
      `tsc --noEmit` on the app reports 0 errors — **corrected 2026-09-13: that
      command (`-p tsconfig.json`) checks no files; `tsc -p tsconfig.app.json`
      has 10 pre-existing errors in jobs.ts, executor.ts and five services, none
      in the files this item touched.** `tools/codegen` reads
      `libs/openapi/src/specs/isis/isis-api.yaml`, not this document, so no
      generated types move._

## V.08 `motion` workflow catalog (`libs/isis/workflows/src/workflows/motion/`)

Every graph: core ComfyUI 0.34.0 nodes first, packs only where named; declares
`custom_nodes_required`, `models_required` (manifest ids),
`gpu_requirement: "H100"`, `estimated_time_seconds`,
`estimated_seconds_per_megapixel_frame`, `output_spec.type: "video"` with the
V.06.01 fields; mp4 via `CreateVideo` → `SaveVideo(format mp4, codec h264)`
unless alpha (then `SaveWEBM vp9`). Sampler defaults come from the ComfyUI
template graphs for each model and are then adjusted against a real render in
V.11 for the eight matrix clips; every other default is labelled
`proof_level: "validated"` in `workflow_info` (enum `rendered` | `validated`),
which V.09.01 surfaces as a badge. Shared controls on every generator: `prompt`,
`negative_prompt` (Wan's published default negative as the preset), `seed`
(random/lock), `fps`, `length` (frames, shown as seconds in the UI),
`resolution` preset enum, and `motion_preset` enum (documented prompt suffixes:
`static camera`, `slow push in`, `orbit left`, `handheld`, `dolly out`, `none`)
— prompt-level guidance, labelled as such, never presented as camera control.

- [x] **V.08.01** `wan22-t2v` — Wan2.2 T2V A14B. Inputs: shared controls,
      `resolution` {`480p_landscape_832x480`, `480p_portrait_480x832`,
      `720p_landscape_1280x720`, `720p_portrait_720x1280`, `square_624x624`},
      `length` default 81 (4n+1, ≤ 121), `steps` default 20 (≤ 40),
      `boundary_ratio` default 0.5 (high→low expert switch), `cfg_high` 3.5,
      `cfg_low` 3.5, `shift` 8.0, `sampler` {`euler`, `uni_pc`, `dpmpp_2m`},
      `scheduler` {simple, beta}, `speed_mode` {`quality`, `lightx2v_4step`}.
      Graph per V.06.04 + `EmptyHunyuanLatentVideo`/`Wan22ImageToVideoLatent`
      (whichever the 0.34.0 T2V template uses — read the template, do not guess)
      → `VAEDecode` → `CreateVideo` → `SaveVideo`, plus `ImageFromBatch (last)`
      → `SaveImage` for chaining. Golden fixture (quality and 4-step). _Done
      2026-09-12. **The latent node is `EmptyHunyuanLatentVideo`** — read out of
      ComfyUI's own `video_wan2_2_14B_t2v` template (its subgraph definition),
      not guessed, along with every sampler default. **One correction: `shift`
      is 5.0, not the 8.0 this item assumed.** The template's two presets both
      split at 0.5 (20 steps at 10, 4 at 2), which the golden checks. The
      boundary is computed in the graph itself with an
      `int(round(steps * boundary_ratio))` template expression, so no helper is
      needed for it. **`speed_mode` was deliberately NOT shipped**: the 4-step
      path needs two `LoraLoaderModelOnly` nodes spliced in, which is V.06.04,
      and an input the graph would silently ignore is worse than an input it
      does not offer. A spec asserts no declared input is unreferenced. 10
      golden specs pass; the whole library is 458 passed and 1 skipped. **Three
      defects found on the way, all fixed:** (1) the renderer dropped
      `constructed_prompt` whenever it rendered to an empty string (a truthy
      check on a legitimately empty value), which made any workflow with an
      empty prompt default die with "name 'constructed_prompt' is not defined";
      (2) a motion preset of "none" concatenated the literal word into the
      prompt, now a `motion_map` where `none` maps to an empty string; (3)
      `EmptyHunyuanLatentVideo`, `ImageFromBatch` and `KSamplerAdvanced` were
      missing from the smoke test's `REQUIRED_CLASSES` and the video inventory,
      so the graph needed three classes nothing guaranteed. `motion` was added
      to the `WorkflowCategory` enum, and `proof_level` and
      `estimated_seconds_per_megapixel_frame` to `workflow_info`._
- [x] **V.08.02** `wan22-i2v` — Wan2.2 I2V A14B. Inputs: `start_image`
      (required), `end_image` (optional → `WanFirstLastFrameToVideo`;
      offline-proved only, labelled `experimental` in the UI until someone
      renders it), `fit` {`match_image_aspect_480p`, `match_image_aspect_720p`}
      (the renderer derives width/height from the image, snapped to multiples of
      16), rest as V.08.01. `clip_vision_output` left unconnected (the 2.2 I2V
      template omits it; verify against the template). _Partly done 2026-09-12 —
      **stays `[ ]` for `end_image` and `fit`.** Landed: the graph, registry,
      taxonomy, golden fixture and 6 specs. **`clip_vision_output` verified
      against the template, not assumed** — `WanImageToVideo.clip_vision_output`
      is `link: null` in ComfyUI's own `video_wan2_2_14B_i2v`, so Wan 2.2 I2V
      needs no CLIP-vision tower (Wan 2.1 did). That disproved a claim in the
      volume manifest, where `clip-vision-h` was recorded as shared by both I2V
      experts; corrected to Animate only, itself to be confirmed in V.08.03. The
      structural point the specs protect: `WanImageToVideo` emits **positive,
      negative and latent**, and both experts consume all three — wiring the
      samplers to `CLIPTextEncode` instead still renders a clip, it just
      silently ignores the image's conditioning. **Still open:** `end_image`
      needs a conditional swap to `WanFirstLastFrameToVideo`, which is the same
      missing capability as `speed_mode` (V.06.04); and `fit` needs the
      width/height derived from the uploaded image's real dimensions, which the
      template DSL cannot do — it belongs at the submission seam with V.05.02._
      _**Both closed 2026-09-12.** `end_image` is a second post-render
      transform, `wan-first-last-frame.ts`, alongside the speed mode. The swap
      is safe because the two node signatures are the same where it matters, and
      that was **read from ComfyUI's own `comfy_extras/nodes_wan.py`, not
      inferred by analogy**:
      `WanFirstLastFrameToVideo(positive, negative, vae,     width, height, length, batch_size, clip_vision_start_image?,     clip_vision_end_image?, start_image?, end_image?)`
      against `WanImageToVideo(…, clip_vision_output?, start_image?)`, both
      returning `(positive, negative, latent)`. That identical return tuple is
      what makes it a retype rather than a rewire, and the specs assert the
      samplers are untouched rather than trusting the comment. It composes with
      the lightning mode — a spec renders both transforms on one graph and walks
      every reference to prove no id collision._ _`fit` is a SUBMISSION-seam
      transform (`fit_to_image`), because it needs the uploaded image's bytes
      and those do not exist until the image is lifted out of its data URL. It
      scales the image's **short** side to the tier — 480p is 832x480 landscape
      and 480x832 portrait, so matching on the long side would make a portrait
      clip cost what a landscape one does a tier up — then snaps both edges to a
      multiple of 16. It runs BEFORE the caps check on purpose: a derived size
      must face the same ceiling as a typed one. No bytes to measure is a
      refusal, not a fall back to the template's default: silently rendering
      832x480 when the request asked to match a portrait still is a clip nobody
      wanted, billed in full._ _**A defect this exposed, fixed here.**
      `WanImageToVideo` sets the latent size but was not in
      `LATENT_SIZE_CLASSES`, so **no Wan image-to-video graph had ever been
      pixel-capped** — not only ones with a derived size, but ones with a
      hand-typed 4096x4096. The list now carries every class in `nodes_wan.py`
      that declares width/height/length/batch_size (read, not guessed from the
      two this initiative happens to use), so a graph added later is capped
      without anyone remembering to come back._ _Both halves are labelled
      EXPERIMENTAL in the catalog, as the item asks: proved against the node
      signatures and the rendered graph, never rendered on a GPU. 13
      golden-graph specs, 6 on the swap, 14 on the fit; 487/487 in
      `libs/isis/workflows`._
- [x] **V.08.03** `wan22-animate` — Wan2.2 Animate 14B. Inputs:
      `reference_image` (character), `driving_video`, `mode` {`animation`
      (character performs the driving motion on the reference's background),
      `replacement` (character replaces the person in the driving video; needs
      `background_video` = driving video and `character_mask` from V.08.05 or an
      uploaded mask video)}, `relight` (bool → relight LoRA), `pose_strength`
      (if `WanAnimate2ToVideo` is used — decide per the 0.34.0 template and
      record which node), `window_frames` 77, `length` ≤ 240 with
      `continue_motion` windows chained by the renderer. Preprocess subgraph:
      `OnnxDetectionModelLoader(yolov10m, vitpose)` → `PoseAndFaceDetection` →
      `DrawViTPose` (pose video) + face crops (face video) → `WanAnimateToVideo`
      with `clip_vision_h` on the reference. Output mp4. _Two golden fixtures
      (`animation` 20 nodes, `replacement` 24) plus 13 specs, and the item's own
      open question answered from source rather than guessed:
      **`WanAnimateToVideo` is the node, not `WanAnimate2ToVideo`** — the 2
      variant drops `face_video`, `background_video` AND `character_mask`, so it
      cannot express `replacement` at all and the preprocess subgraph's face
      crops would have nowhere to go. The only thing that costs is
      `pose_strength`, which exists solely on the 2 variant; one control is not
      worth a whole mode. Pack signatures read at
      `kijai/ComfyUI-WanAnimatePreprocess@0e0b6a2a`: `PoseAndFaceDetection`
      returns five outputs and `face_images` is **1**, not 0 — output 0 is the
      raw POSEDATA that feeds `DrawViTPose`. Both are drawn at the GENERATION
      size, not the driving clip's, or the skeleton is the wrong size for the
      frame. Both ONNX models are named explicitly (`vitpose-l-wholebody.onnx`,
      `yolov10m.onnx`) rather than left to a combo default — the third instance
      in this section of a node that would otherwise download weights the volume
      does not seed. `animation` mode leaves `background_video`/`character_mask`
      **absent, not empty**: Wan reads a supplied background as "composite onto
      this", so passing the driving clip there would silently discard the
      reference's own background; `replacement` without a mask throws instead of
      billing for a no-op. Relight LoRA splices
      `UNETLoader → LoraLoaderModelOnly → ModelSamplingSD3`, same shape and same
      reason as the speed mode. Unlike Wan 2.2 I2V this graph really does take a
      `clip_vision_output`. **NOT done: `length` ≤ 240 via `continue_motion`
      window chaining.** The graph renders ONE window — `length` default 77, the
      node's own — because chaining needs the renderer to feed each window's
      tail latents back in, which the bare `/prompt` graph shape cannot express
      without the job-chain service (V.06.05) driving it; the 240 cap lives in
      `motion-caps` as `maxInputFrames` only._

- [x] **V.08.04** `wan21-vace-edit` — Wan2.1 VACE 14B, one graph, four modes:
      `mode` {`inpaint` (masked replace: `source_video` + `mask_video` +
      prompt/`reference_images`), `restyle` (video-to-video via `control`),
      `extend` (temporal: first `keep_frames` frames as control, rest empty),
      `outpaint` (spatial: `pad_left/right/top/bottom` masks)}, `control`
      {`none`, `depth` (DepthAnythingV2Preprocessor), `pose` (DWPreprocessor),
      `canny` (core Canny), `raw` (use source as-is)}, `strength` 1.0,
      `reference_images` 0–3, `mask_grow` px, `mask_blur` px, shared controls.
      Graph: `WanVaceToVideo` → `KSampler` → `TrimVideoLatent` → `VAEDecode` →
      `SaveVideo`. Golden fixture per mode. _Four golden fixtures, one per mode,
      plus 16 specs. Every signature read from source:
      `WanVaceToVideo(positive, negative, vae, width, height,     length, batch_size, strength, control_video?, control_masks?,     reference_image?)`
      → `(positive, negative, latent, trim_latent)`, and
      `TrimVideoLatent(samples, trim_amount)`._ _**Correction to the item:
      `reference_image` is SINGULAR.** It asks for "reference_images 0–3"; the
      node takes one, so the catalog offers one._ _Two structural traps the
      specs protect. The sampler's positive AND negative come from
      `WanVaceToVideo`, not from the text encoders — VACE writes the control
      track into both conditionings, and wiring the sampler back to
      `CLIPTextEncode` still renders a clip, it just ignores the control
      entirely, which reads as a disobedient model rather than a wrong graph.
      And `trim_amount` comes from VACE's fourth output, an INT: VACE pads the
      latent for its reference frames and the pad has to come back off, or the
      clip opens with frames nobody asked for._ _The four modes are a node-set
      change, so they are a post-render transform (`vace-modes.ts`). `inpaint`
      reads the mask clip as a per-frame MASK; `restyle` supplies no mask at
      all; `extend` builds VACE's own convention — kept frames real, the rest
      grey, masks black then white — out of `ImageFromBatch` + `EmptyImage` +
      `ImageBatch`, with `ImageToMask` over an image BATCH to get a per-frame
      mask track without a node that repeats masks; `outpaint` takes BOTH tracks
      from one `ImagePadForOutpaint`, whose second output is the pad region, and
      **grows `width`/`height` by the pads** — without that VACE renders the
      padded frames back into the original size and undoes the outpaint._ _Three
      refusals rather than expensive no-ops: `inpaint` without a mask, `extend`
      with `keep_frames` outside the clip, `outpaint` with no pads. The last of
      those broke the catalog-wide enum sweep, which renders every option at
      defaults — correctly, since outpaint at pad 0 is not a renderable request.
      The sweep now carries a small, explicitly-named prerequisites table rather
      than the transform going soft._ _**A third instance of the
      run-time-download trap.** `DWPreprocessor` defaults `pose_estimator` to
      `dw-ll_ucoco_384_bs5.torchscript.pt`, which the volume does NOT seed — it
      seeds `dw-ll_ucoco_384.onnx`. Taking the node's default would download
      weights on every cold start, exactly as SAM 3's checkpoint would have
      (V.08.05). Both the pose weights and the bbox detector are pinned to what
      the volume has, and a spec asserts it._ _Nine core classes and the two
      `comfyui_controlnet_aux` preprocessors added to the endpoint inventory and
      the smoke test, with the key/class divergence recorded there:
      `DepthAnythingV2Preprocessor` is the class
      `Depth_Anything_V2_Preprocessor`, `DWPreprocessor` is
      `DWPose_Preprocessor`. 559/559 in `libs/isis/workflows`._
- [x] **V.08.05** `sam3-video-track` — SAM 3 (not 3.1) via ComfyUI-SAM3. Inputs:
      `source_video`, `text_prompt`, optional `points`/`box` on frame 0,
      `threshold`, `propagate_every` n. Outputs: `mask_video` (grayscale mp4,
      lossless-ish `crf 0`) and `overlay_video` (preview). Both saved. This is
      the mask producer for V.08.04 `inpaint`, V.08.03 `replacement`, V.08.06.
      _**A MISSING VOLUME ARTIFACT, which is the important finding.**
      `LoadSAM3Model` takes no filename: it hard-codes
      `models/sam3/sam3.safetensors` and **downloads it from HuggingFace at run
      time if it is absent** (`nodes/load_model.py`, pinned `de0ff5d2`). The
      volume seeds `sam3/sam3.pt` — the `.pt` that ComfyUI-RMBG's `SAM3Segment`
      reads. Same weights, different pack, different filename, so every cold
      start of this graph would have pulled 3.4 GB before doing any work. A
      second manifest row is added, `sam3-safetensors` from
      `apozz/sam3-safetensors`, with size and sha256 taken from HF's
      `paths-info` API and the revision pinned to the branch commit — verified,
      not copied from the `.pt` row. The lint passes at 42 artifacts / 358.30 GB
      of 500. **Seeding it onto the volume is V.02 work and has not happened**;
      this item added the row, not the bytes._ _**Two of the item's own input
      assumptions did not survive the source.** SAM 3 video **cannot mix prompt
      kinds** — `SAM3VideoSegmentation` takes a `prompt_mode` of text/point/box
      and the pack states they are mutually exclusive — so "text_prompt,
      optional points/box on frame 0" is not one graph. This is the text graph;
      points and boxes need their own, and the spec asserts the point/box inputs
      are absent rather than merely unused. And there is no `propagate_every n`:
      `SAM3Propagate` takes `start_frame`/`end_frame`/`direction` and
      propagation is continuous._ _Structural points the specs protect: the clip
      is passed as `video`, not `video_frames`, because the node streams frames
      one at a time from the VIDEO object and the alternative holds the whole
      clip in host RAM (tens of GB on a long 1080p source); `SAM3Propagate`
      returns `(masks, scores, video_state)` and it is the THIRD output that
      `SAM3VideoOutput` needs — feeding it the pre-propagation state still type
      checks and yields masks for a clip that was never tracked;
      `SAM3VideoOutput` returns `(masks, frames, visualization)` and the overlay
      is output 2, so a graph saving output 1 would show a preview with no masks
      and look like the tracker found nothing._ _`MaskToImage` was missing from
      the endpoint inventory and the smoke test — core, but no image graph needs
      it, so it was absent until the first mask-producing video workflow. SAM
      3's MASK is single-channel and `CreateVideo` wants IMAGE; wiring it
      straight in is a type error the worker only reports after a cold start.
      Added to both._ _Golden fixture + 9 specs; 509/509 in
      `libs/isis/workflows`; registry, taxonomy record and caps in place._
- [x] **V.08.06** `birefnet-video-matte` — BiRefNet\*HR-matting per frame
      (`BiRefNetRMBG` batch mode from ComfyUI-RMBG) optionally restricted to a
      `mask_video` region from V.08.05 (`refine_within_mask`), `edge_erode`,
      `edge_feather`; outputs `rgba_video` (`SaveWEBM vp9 yuva420p`, alpha
      verified by decoding one frame in the spec) and `matte_video` (grayscale
      mp4). Hair / sheer fabric / veil test clip in V.11. **\*The alpha polarity
      is the trap, and it was settled from source rather than convention.**
      `BiRefNetRMBG` merges its MASK straight in as the alpha channel —
      `Image.merge('RGBA', (r, g, b, mask))` in `py/AILab_BiRefNet.py` at
      `58f1947a` — so **1 = subject = opaque**. `JoinImageWithAlpha` applies
      `1.0 - alpha` before concatenating (`comfy_extras/nodes_compositing.py`).
      So the restricted matte must be INVERTED on the way back in. Skipping that
      yields a clip where the subject is transparent and the background is
      solid, which renders, saves, and is wrong in the one way nobody checks.
      There is a spec whose whole job is that inversion.\_ _`refine_within_mask`
      is a third post-render transform, `mask-restrict.ts`: supplying a mask
      clip adds a branch (`LoadVideo` → `GetVideoComponents` → `ImageToMask` →
      `MaskComposite multiply` → `InvertMask` + `SplitImageWithAlpha` →
      `JoinImageWithAlpha`) and rewires BOTH outputs through it. `multiply` over
      two subject-masks is intersection, which is what "within" means:
      BiRefNet's soft edge is kept, but only inside what SAM 3 tracked. Absent
      mask clip returns the same graph object, so the plain path is provably
      untouched, and a spec walks every reference in the restricted graph to
      prove nothing dangles._ _`edge_feather` and `edge_erode` map onto the
      node's own `mask_blur` (0–64 px Gaussian) and `mask_offset` (±20 dilation
      passes) rather than onto core mask nodes. `FeatherMask` would have been
      the wrong choice and the source says why: it takes per-edge
      left/top/right/bottom insets from the FRAME border, not a radius on the
      matte's own boundary._ _`refine_foreground` is on: it is Fast Foreground
      Colour Estimation, which is what stops a dark halo where a light
      background bled into the edge pixels. The RGBA is written with `SaveWEBM`
      VP9 — the only writer in this image that keeps an alpha channel;
      `SaveVideo`'s h264 would flatten it onto black, which reads as "the matte
      failed" rather than "the writer dropped a channel"._ _Four core classes
      the restrict branch needs (`MaskComposite`, `InvertMask`,
      `SplitImageWithAlpha`, `JoinImageWithAlpha`) plus `ImageToMask` were
      missing from the endpoint inventory and the smoke test; all added. **Not
      done, and it needs a GPU:** the item asks for the alpha to be verified by
      decoding a frame of a real output. That is a live check and belongs to
      V.11 — what is verified here is that the graph declares VP9 and routes the
      channels correctly._ _Golden fixture + 12 specs; 520/520 in
      `libs/isis/workflows`._
- [x] **V.08.07** `sam3-track-then-vace` — composition: V.08.05 → mask grow →
      V.08.04 `inpaint` with prompt and optional reference image, in one graph.
      The "fix or replace part of an existing video" flow. _**"In one graph" is
      the whole point and the spec pins it.** The MASK goes straight from
      `SAM3VideoOutput` through `GrowMask` into `WanVaceToVideo`. Running
      V.08.05 and V.08.04 as a two-step chain instead would write a mask clip,
      upload it and read it back — three I/O steps and a lossy h264 round trip
      for data that never needed to leave the GPU. The spec asserts exactly one
      `LoadVideo` and NO `MaskToImage`/`ImageToMask` anywhere, which is what
      that round trip would look like if it crept back in._ _`mask_grow`
      defaults to 12 px and is there for a specific reason: a tight track leaves
      the subject's own edge inside the KEPT region, so the replacement has to
      blend against the thing it is replacing. Growing hands that edge to the
      generator. Negative values shrink, and the spec renders 0 and −8 as well._
      _Same two traps as its parents, re-asserted here because a composition is
      where a correct sub-graph gets miswired: `SAM3Propagate`'s THIRD output is
      the state `SAM3VideoOutput` needs, and the sampler's positive AND negative
      come from `WanVaceToVideo`. `obj_id` is −1 so every tracked object becomes
      one region — a region edit wants one mask, not the first object's._ _The
      optional reference still needed a fourth post-render transform,
      `optional-image-input.ts`, and it is the general form of a thing the other
      transforms each did for one input: a `LoadImage` with an empty filename is
      not "no image", it is a node that fails at execution. `GrowMask` added to
      the inventory and the smoke test._ _Golden fixture + 10 specs; 569/569 in
      `libs/isis/workflows`._
- [x] **V.08.08** `gimm-vfi-interpolate` —
      `DownloadAndLoadGIMMVFIModel     (gimmvfi_f_arb_lpips_fp32)` →
      `GIMMVFI_interpolate(multiplier {2,3,4},     ds_factor)`; `model`
      {`gimmvfi_f`, `gimmvfi_r`}; output fps = source × multiplier (≤ 60). Input
      via `LoadVideo` → `GetVideoComponents` (keeps the audio track and re-muxes
      it in `CreateVideo`). _**Three of this item's own premises were wrong, and
      reading the source is what found them.** From
      `kijai/ComfyUI-GIMM-VFI@4c9a3123` `nodes.py`: the input is
      `interpolation_factor` (INT, 1–100), **not** `multiplier` (a 2/3/4 combo);
      `GIMMVFI_interpolate` also **requires a `seed`**, which the item does not
      mention and whose absence ComfyUI would reject at `/prompt` after a cold
      start; and the model combo values carry the `.safetensors` extension. The
      catalog keeps `multiplier` as the operator-facing name and renders it into
      `interpolation_factor`, so the item's vocabulary survives where it is a UI
      choice and the node's spelling wins where it is a contract._ _The frame
      arithmetic was read too, not assumed: the loop appends the first frame,
      then `interpolation_factor - 1` synthetic frames plus the next original
      per interval, so N frames become **1 + (N-1)×k**, not N×k. That is why
      `CreateVideo.fps = source_fps × multiplier` preserves the real duration —
      the output spans the same time — and the spec pins four rate/multiplier
      pairs including a fractional source rate._ _Audio survives:
      `GetVideoComponents` returns
      `(images, audio, fps, bit_depth, color_space)` and output 1 goes straight
      to `CreateVideo`, which the spec asserts by index. A graph that skipped it
      returns a silent clip, which looks like the source had no sound. Only
      output 0 of `GIMMVFI_interpolate` is wired on — output 1 is a flow-tensor
      debugging aid that would otherwise become a second video._ _**Two defects
      this exposed, both fixed.** It is the first catalog workflow to declare a
      `video` input, and that showed (1) the executor's
      `inferCatalogInputDefinition` had no `video`/`audio` case, so a clip
      inferred as `object` and the dashboard would have offered a JSON box where
      a file picker belongs; and (2) the RunPod handler's catalog-input
      validation had no branch for them either. Both now handle video and audio
      as files, with the catalog's `accept` list narrowing the picker; the
      handler checks for a non-empty string because an empty one silently
      becomes "no file" and the graph renders from nothing. The
      schema-compatibility harness is what caught both — it compares the
      catalog's input types against the API and RunPod surfaces, and it had
      nothing to catch until a workflow used the type._ _Golden fixture + 7
      specs; 500/500 in `libs/isis/workflows`; registry, taxonomy record and
      motion caps all in place._
- [x] **V.08.09** `flashvsr-upscale` — FlashVSR v1.1: `pipeline` {`full`,
      `tiny`, `tiny_long`}, `scale` {2, 4} capped by V.04.02, `tile_dit`,
      `unload_dit_before_decode`; audio track preserved through
      `GetVideoComponents` → `CreateVideo`. Output ≤ 1080p. _**Four of the names
      in this item are wrong**, read against
      `lihaoyun6/ComfyUI-FlashVSR_Ultra_Fast@4820b3f0` `nodes.py`: the input is
      `mode`, not `pipeline`; its long value is spelled **`tiny-long` with a
      hyphen**, not `tiny_long` — a value ComfyUI would reject at `/prompt`
      after a cold start and after the model had been paged in; `tile_dit` is
      `tiled_dit`; `unload_dit_before_decode` is `unload_dit`. And `scale` is an
      INT with min 2 / max 4, so **3 is legal** where the item wrote {2, 4}; the
      spec renders it. `pipeline` survives as the operator-facing label because
      that is a UI name, and the node's spelling wins everywhere it is a
      contract._ _One more mismatch recorded but not needed here: the pack
      registers its pipe node under the key `FlashVSRInitPipe` while the class
      is `FlashVSRNodeInitPipe`. This graph uses the single-node `FlashVSRNode`
      form, which needs no PIPE and adds nothing the advanced pair would — but
      that key/class divergence is the exact hazard the smoke test's pack
      section exists for._ _`model` is pinned to `FlashVSR-v1.1` because the
      pack joins `<models_dir>` with the combo value verbatim, which is why the
      volume folder carries the `-v1.1` suffix. Tiling is on by default for both
      the transformer and the VAE: a 24 GB card cannot run this untiled at 4x.
      The source audio is carried across — an upscale changes the pixels, not
      the soundtrack, and dropping it is the kind of loss nobody notices until
      the clip is in an edit._ _The 1080p ceiling is real and enforced by
      `checkMotionCaps`: cost scales with scale² because the diffusion pass runs
      at the OUTPUT resolution, so 4x on a 720p source is 8.3 megapixels a
      frame. The spec asserts that case is refused, and that the violation names
      the frame back as `3840x2160` rather than as a pixel count._ _Golden
      fixture + 9 specs; 529/529 in `libs/isis/workflows`._
- [x] **V.08.10** `ltx23-av` — LTX-2.3 22B dev, synchronized audio + video.
      Inputs: `mode` {`t2v`, `i2v`}, `prompt`, `negative_prompt`, `start_image`
      (i2v; `LTXVImgToVideoInplace`, `start_strength`), `generate_audio` (bool;
      false → `LTXVEmptyLatentAudio` still present but audio discarded at mux),
      `audio_reference` (optional `LoadAudio` → `LTXVReferenceAudio`),
      `resolution` {`1280x720`, `720x1280`, `1024x576`, `1536x864`}, `length`
      frames 8n+1 default 121, `fps` {24, 25}, `steps` default 30 (≤ 40),
      `cfg_video` 3.0, `cfg_audio` 3.0 (`LTXVDualCFGGuider`), `two_stage` (bool
      → spatial x2 upscaler second pass, doubles cost estimate), `seed`. Graph:
      `CheckpointLoaderSimple     (ltx-2.3-22b-dev)` +
      `LTXAVTextEncoderLoader(gemma_3_12B_it)` + `LTXVAudioVAELoader` →
      `LTXVConditioning` → `EmptyLTXVLatentVideo` + `LTXVEmptyLatentAudio` →
      `LTXVConcatAVLatent` → `SamplerCustomAdvanced` → `LTXVSeparateAVLatent` →
      `VAEDecode` + `LTXVAudioVAEDecode` → `CreateVideo(images, audio)` →
      `SaveVideo(mp4, h264)`. `output_spec.audio:     true`. Golden fixture.
      _**Two of the four resolutions this item lists are not renderable**, and
      the motion caps caught it. LTX's latent patch is 32 px —
      `EmptyLTXVLatentVideo` declares `step=32` on width and height — and 720/32
      = 22.5, so `1280x720` and `720x1280` both fail. They are `1280x704` and
      `704x1280`, and a spec now walks EVERY option through `checkMotionCaps`
      rather than trusting the list._ _**`audio_cfg` defaults to 7.0, not the
      3.0 the item says.** Read from `LTXVDualCFGGuider`; audio needs more
      guidance than video and the catalog follows the node._ _The product claim
      is that the two tracks are generated TOGETHER, and the specs assert that
      shape rather than the outcome: the audio latent is concatenated with the
      video latent BEFORE one `SamplerCustomAdvanced` pass and separated after.
      Two samplers muxed together would also produce a clip with sound and would
      be a different product. The frame rate goes to `LTXVConditioning` AND to
      `LTXVEmptyLatentAudio`, so both tracks are laid out against one clock —
      two values there is a clip whose sound drifts. And `SamplerCustomAdvanced`
      returns `(output, denoised_output)`; taking index 1 is the
      plausible-looking mistake that changes what is decoded._ _Four nodes are
      in `nodes_lt_audio.py`, not `nodes_lt.py` (`LTXAVTextEncoderLoader`,
      `LTXVAudioVAELoader`, `LTXVAudioVAEDecode`, `LTXVEmptyLatentAudio`) —
      worth knowing because a missing one is a graph that renders silent. The
      text-encoder loader needs BOTH the encoder file and the checkpoint, and
      the audio VAE loads from the CHECKPOINTS folder because it lives inside
      the same file._ _`generate_audio: false` drops the mux input and nothing
      else: LTX generates the two together, so removing the audio latent would
      change the video. `audio_reference` splices `LTXVReferenceAudio` into the
      guider on all THREE of its outputs — taking only the conditionings leaves
      the guider on the unmodified model and drops the identity guidance
      silently._ _Two golden fixtures (t2v, i2v) + 13 specs; 582/582 in
      `libs/isis/workflows`. The smoke list was DEDUPLICATED while adding to it:
      five names had been added twice across V.08.04–08.07 (77 unique now, zero
      duplicates)._
- [x] **V.08.11** `still-to-polished-clip` — the product pipeline as a V.06.05
      chain definition (JSON in the same folder, `kind: "chain"`): Chroma still
      (`chroma-txt2img`, image endpoint) → `wan22-i2v` →
      `gimm-vfi-interpolate     ×2` → `flashvsr-upscale ×2`. The chain runner
      resolves `$prev`. Spec on the chain document; the runner is proved live by
      V.11.02 step 2 (VFI→VSR); the full four-step chain ships as
      `proof_level: validated`. _**The lint found two real errors in my own
      chain the moment it ran**, which is the argument for it existing. The
      first step set `width` and `height`; `chroma-txt2img` declares neither —
      it takes an `aspect` PRESET. And none of its presets is 16:9: the widest
      landscape is `1216x832` at 1.46:1 against Wan's 480p landscape at 1.73:1.
      So the chain picks chroma's widest and lets `wan22-i2v` derive its own
      size with `match_image_aspect_480p` — which is exactly what that input was
      built for. Declaring a tier instead would stretch the still, because Wan
      does not letterbox. `fitDimensions(1216, 832, 480, 16)` returns 704x480,
      run rather than asserted; at scale 2 that is 1408x960, under the 1080p
      cap._ _**Deviation, deliberate: chains live in `src/chains/`, not in
      `workflows/<category>/`.** A chain has no nodes, no models and no output
      spec — it would fail the workflow schema, and `workflows.spec.ts`
      validates every JSON it finds in the workflow folders. Co-locating them
      would need an exception in every scanner, and an exception in each scanner
      is how the next scanner gets it wrong._ _`lintChainDocument` is the only
      thing that reads a chain and the workflows it names TOGETHER, so it is the
      only thing that can catch what a chain gets wrong: an input the workflow
      does not declare, a `$prev` on the first step, an output index the
      previous step does not produce, a near-miss reference, an unregistered id.
      It reports all of them at once — a chain is edited as a unit and fixing
      one name per round trip is four round trips. Each failure mode has its own
      spec._ _`proof_level: validated` with a `proof_note` saying plainly that
      nothing in the chain has been rendered on a GPU, and that only a job id in
      the evidence file may raise it. A chain is the easiest place to overclaim:
      four steps each having a golden fixture is not the chain having run._ _14
      specs._
- [x] **V.08.12** Registry, three lints, `workflows.spec.ts` cases, provider
      compatibility (`runpod-worker-comfyui` only), generation-type routing for
      every id above; adversarial pass over the folder (no placeholder prompts,
      no `TODO`, every `models_required` present in the manifest, every
      `class_type` in the video node snapshot); `proof_level` set per
      workflow/mode from the V.11 evidence rows, `validated` everywhere else —
      never `rendered` without a job id in the evidence file. Evidence block.
      _**The sweep found a defect I had introduced in five graphs**, which is
      the argument for writing it mechanically rather than re-reading nine
      files. `models_required` is checked at submit against FILENAMES — the
      executor's `volumeModelNames` collects `file`, `destPath` and the destPath
      basename — and the five graphs written this session listed manifest IDs
      (`gimmvfi-f`, `sam3-safetensors`, …). Every one of them would have been
      refused with `MODEL_NOT_ON_VOLUME` after a cold start. All nine now use
      the destination basename, which is also the spelling a node's own combo
      value uses (`unet_name`, `vae_name`, `ckpt_name`)._ _My first version of
      the assertion was wrong in the same direction: it compared against
      manifest ids, which would have passed the five broken graphs and failed
      the two correct ones. It now builds the name set **exactly as the runtime
      builds it**, and a second check walks the rendered graph for anything that
      looks like a weight filename and asserts it appears in `models_required` —
      so the declaration and the graph cannot drift apart._
      _`motion-catalog-contract.spec.ts`, 8 checks over every graph and every
      enum option of every graph (four VACE modes × five control values
      included): registry ↔ folder agreement both ways; models present by the
      runtime's own name set; every rendered `class_type` in the endpoint
      inventory; no dangling reference and no unsubstituted `{{template}}`
      anywhere; no placeholder prompt or confession word (the stub scan's
      vocabulary applied to the catalog, because a workflow is DATA and a TODO
      in it reaches no compiler); `proof_level` present on all nine; and
      `outputType`/`gpuRequirement` coherent._ _**Every graph is `validated`,
      none is `rendered`.** The spec enforces that `rendered` requires the
      workflow id to appear in `isis-chroma-runpod-evidence.md` — nothing in
      this catalog has run on a GPU, and that assertion is what stops the word
      drifting in on optimism. Each graph also carries a `proof_note` saying so
      in its own file._ _The three lints and the `workflows.spec.ts` cases
      already covered the new graphs (they iterate the whole catalog); 590/590
      in `libs/isis/workflows`. Provider compatibility is structural rather than
      declared: `motion` is in `WORKER_COMFYUI_ONLY_CATEGORIES`, so these graphs
      are deliberately absent from the general resolver — which is what
      V.08.02's own regression proved when it broke the catalog-registration
      tests._

## V.09 Dashboard (existing `apps/isis/web`)

- [x] **V.09.01** Workflow Details renders `video`/`audio` inputs: file picker
      with client-side probe (`<video>` metadata → duration, fps if exposed,
      dimensions, size), size cap from V.05.01, frame-count estimate shown
      against the V.04.02 cap before submit; drag-in of an Outputs card as the
      source (chaining from the UI); a `validated, not yet rendered` badge for
      workflows/modes whose `proof_level` is not `rendered`. Vitest spec with
      the `wan22-i2v` schema. _Partly done 2026-09-12 — **stays `[ ]` for the
      Outputs-card drag-in.** Landed: `video`/`audio` field kinds through
      `kindFor`, pickers whose `accept` is the WORKFLOW's allowlist narrowed by
      the app's (never widened — the submission sniffs the same set, so offering
      more just moves the rejection later), per-field `max_bytes` and
      `max_frames` shown in the help line, `assertMediaAcceptable` refusing a
      bad file BEFORE a byte is read, an injectable `probeMediaFile`, and the
      `validated, not yet rendered` badge driven by `proof_level`._ _**"fps if
      exposed" resolves to: it is not.** `HTMLVideoElement` gives duration and
      dimensions and no frame rate; deriving one needs
      `requestVideoFrameCallback` sampling, which costs real playback time and
      is still an estimate. So `MediaProbe.fps` is typed `undefined` with the
      reason in the type, and `estimateFrames` takes the rate from the operator
      or the workflow. With no rate the answer is the STRING "frame count
      unknown", not a number — an invented count that happens to pass the cap is
      worse than no check, because the job then fails on the GPU after being
      billed. Both branches are spec'd._ _The size default is 512 MB, not
      V.05.01's 6 MB inline ceiling: above that ceiling the submission routes
      the clip to the volume rather than refusing it (V.05.03), so the browser's
      job is to stop something absurd, not to enforce a transport boundary. A
      workflow's own `max_bytes` wins when set._ _The chosen FILE is the form
      value, not a data URL: a clip can be hundreds of megabytes and the
      submission decides the transport. A probe that fails leaves the clip
      submittable and says what was lost — the API measures the real file either
      way (V.05.05)._ _A test premise of mine was wrong and the fix is
      instructive: `userEvent.upload` honours the `accept` attribute, so the
      "refuses a bad container" test was passing through a path the picker
      already blocks. It now tests both halves — the dialog filtering it out,
      and `assertMediaAcceptable` catching a drag-in that bypassed the dialog._
      _**A pre-existing break fixed on the way through:** `apps/isis/web` did
      not typecheck at all. `HIGH_COST_TYPE_WEIGHTS` is a
      `Record<GenerationType, number>` and the five video generation types had
      been added to `ISIS_GENERATION_TYPES` without weights, so the file failed
      to compile. Weighted against the existing text-to-video 4: interpolation
      and segmentation cheapest (no diffusion), video-upscale dearest (a
      diffusion pass per frame at the OUTPUT resolution)._ _11 component specs +
      11 util specs, 30/30 in the touched files; `npx tsc     --noEmit` on the
      web app now clean._ _**Closed 2026-09-12 with the drag-in.** An Outputs
      card is a drag source and a `video`/`audio` picker is a drop zone; the
      dropped value is the **worker path**, not the URL —
      `volume/<jobId>/<name>` when the output carries a `volumeKey`, so the next
      job opens the file off the mount instead of downloading bytes that never
      left. That is the same rule `workerPathForOutput` applies server-side when
      a chain step resolves `$prev.outputs[0]`: one behaviour, reached two ways,
      so a hand-chained job and a dragged one submit the same thing. The payload
      rides a private MIME type (`application/x-isis-output+json`) because
      `dragover` deliberately hides the dragged DATA and exposes only
      `dataTransfer.types` — the type IS the accept/refuse decision, and
      `text/plain` would make it unanswerable. A drop is refused with the reason
      BEFORE the form takes it: a still onto a clip field, any output onto an
      audio field (the catalog produces clips and stills, and a muxed clip is
      not an audio file), an output with neither volume key nor URL, and a clip
      over the field's `max_frames` — that last check is possible only here,
      since the browser cannot see a local file's frame count at all but the API
      measured this one from the bytes. `readOutputDrag` never throws: a desktop
      can drop anything._ _**The drop zone needed a source on the same page.**
      The Outputs page is a different route and a drag does not survive one, so
      Workflow Details grows a `ChainSourcePanel` strip of recent completed
      outputs — shown only when the workflow has a `video`/`image` input, and an
      output stranded on the volume is labelled unusable rather than offered and
      then refused on drop._ _`proof_level` now actually reaches the badge: it
      was read off the definition but stopped at the executor, so the page had
      nothing to pass. Carried through `WorkflowCapabilityMetadata` →
      `/workflows/catalog` → `CatalogWorkflowEntry.proofLevel`, absent rather
      than defaulted (defaulting to `validated` would make the claim on the
      definition's behalf), with 4 resolver specs including "nothing in the
      catalog claims `rendered`"._ _18 + 5 + 6 unit specs, and **verified in
      chromium** (`e2e/workflow-chain-drag.spec.ts`, 2 tests): only a real
      browser runs an actual HTML5 drag — `draggable` honoured, `dragstart`
      firing, `dragover` calling preventDefault so the drop is allowed at all,
      and the payload surviving the browser's own DataTransfer. Miss that
      preventDefault and every unit test still passes while nothing can be
      dropped._ _**Three failures the full web suite had been hiding**, found by
      running all 140 files rather than the touched ones:
      `GENERATION_TYPE_PROFILES` was asserted `toHaveLength(18)` and the five
      video generation types made it 23 (now asserted against the manifest,
      which cannot rot); `JobsPage.spec` mocked the job list with
      `mockResolvedValueOnce` behind a 4-second poll, so the second fetch
      returned the one-job default and collapsed the live-status fan-out — it
      passed alone and failed in a full run; and `App.e2e.spec` had been looking
      for a "Service Health" heading since f1c4fc3b5da renamed it "Service
      Readiness" in August. 140 files / 1074 tests green._
- [x] **V.09.02** Job Submission Studio: seconds ↔ frames slider (respecting
      `4n+1` / `8n+1`), resolution preset buttons, expert-split visual for
      `boundary_ratio`, `speed_mode` toggle with the cost delta, estimated cost
      line from V.04.03, disabled submit with reason when the VIDEO ledger is
      exhausted (separate from the image ledger). Spec. _Partly done 2026-09-12
      — **stays `[ ]` until the controls are wired into the 3,938-line
      `JobSubmissionStudio.tsx` itself.** All six pieces exist and are spec'd as
      arithmetic in `motion-submit-utils.ts`, which is the part that can be
      wrong: `secondsToFrames` snaps through the same `snapMotionFrames` the API
      uses and RETURNS the note ("48 frames is not 4n+1; using 45") because
      silently rendering 2.8 s when 3 s was asked for looks like a bug in the
      model; `resolutionPresets` carries each size's cost relative to the
      cheapest OFFERED and marks the ones the caps refuse; `expertSplit` returns
      STEP COUNTS rather than the ratio, because `boundary_ratio` is where the
      high-noise expert hands its leftover noise on, not "how much of the
      video", and an operator reading it the other way sets it inverted;
      `videoSubmitGate` names the VIDEO budget explicitly, since an operator
      told only "budget exhausted" would reasonably think image jobs were
      blocked too._ _A missing ledger ALLOWS rather than blocks: that is a dev
      stack without Redis, not a spent budget, and the API's own gate is already
      fail-closed — the UI's job is not to invent a refusal._ _Two of my own
      test premises were wrong and both are recorded in the spec: the cheapest
      preset in the fixture is the 624 square, not the 480p landscape, so
      anchoring "relative cost" on a NAME rather than on the list was the
      mistake; and the 2.31x ratio between the two named tiers has to be taken
      from `megapixels`, because dividing two 2-decimal `relativeCost` values
      moves the answer by more than the assertion's tolerance._ _**An alias gap
      fixed on the way through:** `apps/isis/web/vitest.config.ts` carries its
      OWN alias list and never had `@isis/workflows/motion-caps`. Nothing had
      imported it under test, so an import that worked in the app build failed
      the moment a test touched it. Both motion aliases added._ _18 specs._
      _**Mounted 2026-09-12.** The controls went in as `MotionSubmitControls`
      driven by a new `motion-presets.ts`, mirroring `chroma-presets.ts` — one
      preset per motion graph carrying the workflow id, the generation type, the
      graph's own resolution map, the frame rate it renders at and the catalog's
      cost rate, all pinned to the JSON on disk by `motion-presets.spec.ts`.
      That drift has no other alarm: the Studio would keep showing an old rate
      or an old size list and every other test would pass while the operator
      planned around numbers the graph stopped using._ _**Six of the ten graphs
      have no length, size or step controls at all** — they take a clip in and
      read everything off it. Their presets say `derivesFromSource` and the
      panel renders that sentence instead of sliders that would submit values
      the graph ignores._ _Three premises the catalog corrected on the way
      through: the resolution map is **per graph**, not shared (t2v offers
      `square_624x624`, which is the CHEAPEST size, and i2v adds two aspect
      entries that match the input image), so a shared constant was replaced by
      each graph's own map; LTX declares `fps` as an **enum of strings** and a
      slider cannot divide by `"25"`, so the preset carries it as a number and
      the spec asserts the conversion; and every preset must set `steps` in BOTH
      the JSON and the Studio's own field, because
      `buildStudioSubmissionRequest` applies the form's numeric fields AFTER the
      extra parameters, so LTX's 30 was being silently overridden by the form
      default of 20._ _`mergeMotionControlValues` writes the resolution NAME
      rather than width and height (the graph maps the name itself; pixels would
      be ignored) and omits the boundary ratio and `speed_mode` on graphs that
      declare neither. `applyMotionPreset` keeps a hand-pasted data URL still
      across a preset switch AND a volume clip path from V.09.01's drag-in;
      losing that means re-uploading hundreds of megabytes._ _The speed-mode
      saving is stated as a CEILING with the reason ("the decode does not shrink
      with the step count"): it scales the catalog rate by 4/steps, which is a
      documented approximation, not a measurement._ _11 + 18 + 8 specs, 143
      files / 1116 tests green, and **verified in chromium**
      (`motion-runpod-dashboard.spec.ts`, second test): the length the control
      DISPLAYS is the length the submission box CONTAINS, a resolution click
      reaches the JSON, and a clip-in graph offers nothing to choose. One full
      suite run flaked two unrelated files under load; both pass in isolation
      and the next full run was green._
- [x] **V.09.03** Jobs page: phases `queued` → `cold start` → `uploading input`
      → `executing` → `fetching output`, elapsed per phase, `Cancel`. Spec.
      _Partly done 2026-09-12 — **stays `[ ]` until the timeline is rendered in
      `JobsPage.tsx`.** Landed: the API change that makes it possible at all,
      plus the derivation and 15 specs._ _**The stage was published as an EVENT
      and never persisted**, so a dashboard that POLLS the job — which is what
      the Jobs page does — could never see which phase a job was in.
      `updateProgress` now writes `progressStage` and `stageEnteredAt` onto the
      record, and `stageEnteredAt` is stamped only when the stage actually
      CHANGES, so elapsed-per-phase is measurable rather than reset by every
      progress tick._ _**What the timeline refuses to invent is the point.**
      Only `queued` and the total run are measurable from a job record; a passed
      phase's duration genuinely is not, because only the CURRENT stage
      timestamp is kept. So a passed phase reports
      `no per-phase timing reported` rather than a plausible split — four
      invented numbers would be worse than one honest gap, since the whole
      reason to read this panel is to find where the time went. A finished job's
      unreported phases are `skipped`, not `pending`: "pending" on a completed
      job reads as a stuck pipeline._ _**A substring collision found by its own
      spec:** `"uploading"` contains `"load"`, so an unanchored cold-start
      matcher read every upload as a boot. That is the one pair an operator most
      needs told apart — a slow upload is a network problem, a slow boot is a
      model-size problem. Transfer is now matched first and `load` is
      word-anchored, with a spec for each._ _An unrecognised stage maps to
      `executing` rather than to nothing: that is where a worker spends nearly
      all its time, and claiming a more specific phase from a string we do not
      recognise would be a guess. `canCancel` is false on a terminal job,
      because a Cancel that does nothing reads as a broken button._ _**Mounted
      and verified in chromium 2026-09-12.** The strip renders under the
      progress bar in the jobs table, with `data-state` per phase so the styling
      is derived rather than hand-set. Cancel already existed on the page._
      _**The browser run caught a bug the unit tests missed.** A TERMINAL job's
      last reported phase was marked `skipped` — the strip claimed the step that
      produced the output never ran. `index === currentIndex` was being read as
      "after the current phase", which is right for a running job and wrong for
      a finished one. No unit fixture had paired a terminal status WITH a
      reported stage. Both halves are pinned now: a completed job's last phase
      is `done`, and a failed job's unreached phases are still `skipped`,
      because those demonstrably did not happen._
      _`npx playwright test --project=chromium --workers=1     e2e/motion-runpod-dashboard.spec.ts`
      → **1 passed (4.5s)** with the phase assertions added. Server torn down,
      port confirmed free with `lsof`._
- [x] **V.09.04** Outputs page: `<video controls playsinline>` with poster,
      checkerboard behind alpha webm, audio indicator, duration/fps/frames/
      resolution/cost/execution/cold-start badges, download via API stream
      (range-capable). Spec. _Partly done 2026-09-12 — **stays `[ ]` until the
      card is mounted in the 4,451-line `OutputsPage.tsx`.** The card and its
      reader exist and are spec'd: `MediaOutputCard` + `media-output-utils.ts`,
      15 specs._ _**The gap this closes:** `pickJobOutputPreview` finds the
      first IMAGE and returns null otherwise, so a motion job currently shows no
      preview at all. `pickMediaOutput` prefers the CLIP over the still a motion
      job also saves — showing the last frame instead would look like the render
      produced an image — and pairs each file with ITS OWN `outputFiles[i]`
      facts rather than the first entry's._ _`playsinline` is not decoration:
      without it iOS Safari takes the video fullscreen the moment it plays,
      which in a grid of outputs is hostile. The poster is the graph's own last
      frame, so a grid draws itself without decoding video — and a
      present-and-null `posterUrl` passes `undefined` rather than an empty
      string, because an empty `poster` makes the browser request the PAGE as an
      image._ _A fact that was not measured is OMITTED, not rendered as zero: a
      0.00 s duration from "not measured" and one from "the clip is empty" look
      identical and only one is a bug worth chasing. The fps badge carries a
      hover note saying it is the AVERAGE over the track, because 12.8 on a
      truncated clip is otherwise a bug report._ _The checkerboard fires on a
      declared alpha and ALSO on an undeclared VP9 WebM — that is the shape that
      carries alpha here, so it is treated as possibly-transparent rather than
      assumed opaque. And a clip whose SigV4 fetch failed is not offered as
      playable at all: a `<video>` pointed at the S3 URL fails with a network
      error the operator cannot interpret, so the card says why and offers
      nothing to click._ _**Wired where the old code was actually lying.**
      `JobsPage`'s output cell read `pickJobOutputPreview` and therefore
      rendered the words **"no image"** for a completed motion job — not merely
      missing UI, but the table asserting something false about a job that
      produced 81 frames. The cell now plays the clip with the graph's own last
      frame as its poster, captions it with what was measured from the FILE
      (duration / frames / fps / size / silent / cost / cold start), and says
      **"on volume"** rather than rendering a `<video>` the browser cannot load
      when the SigV4 fetch failed. Its empty state is now "no output" rather
      than a medium-specific claim. 6 specs on the cell; the page's existing 7
      still pass._ _**Mounted on the Outputs page 2026-09-12.** That page reads
      output-REGISTRY rows, not jobs, so `pickMediaOutput` could not be reused:
      a registry row carries `duration` in SECONDS, a `dimensions` object, and
      no `outputFiles[i]` facts at all. `mediaOutputFromRecord` converts the
      unit (a 5.06 read as milliseconds renders as "0.01s") and OMITS what the
      row does not carry — a row has no first-class fps, codec or audio flag,
      and a 0 fps badge reads as a measurement; they are read from `metadata`
      when the persister stamped them there._ _The preview refuses to render a
      player until a download URL exists: the registry stores a bucket KEY, and
      a `<video>` pointed at nothing fails with a network error the operator
      cannot interpret. 6 + 3 specs._
- [x] **V.09.05** RunPod page: two spend meters (image / video), two endpoint
      health blocks, one kill switch each, volume size + monthly cost line from
      `infra/runpod/volumes/desired-state.json`. Spec. _Partly done 2026-09-12 —
      **stays `[ ]` until the panels are mounted in the 1,564-line
      `RunPodPage.tsx` and the second kill switch is wired.** Landed: the API
      half and the presentation logic, 13 specs._ _**The API was only ever
      reporting ONE ledger.** `/jobs/runpod/cost/today` read the image ledger
      and nothing else, so a video meter had nowhere to come from. It now
      returns both **in one response** — deliberately, because two meters
      fetched separately can show two different instants, and that is exactly
      when somebody reads "image 90% spent, video 10%" and acts on a state that
      never existed. The video half is `null` when no video endpoint is
      configured (a normal complete state) and also when the video ledger itself
      cannot be read, since a broken video ledger must not take the image meter
      down with it. Added to `RunPodCostTodaySnapshot` and the client dist
      rebuilt._ _Why two meters rather than one total: an H100 second costs
      roughly 4.3x a 4090 second, so a combined "60% spent" hides which half is
      doing the spending — the only thing an operator can act on._ _The warn
      band is 80%, not 95%: the video budget is $6 and one 720p clip can cross
      it, so a band that only appeared at 95% would usually be skipped. An
      over-budget bar is CLAMPED while the real numbers are still reported — the
      bar is a picture, the numbers are the fact. A disabled ledger is labelled
      "historical rather than enforced", because a number that looks like a
      budget and gates nothing is the most misleading thing this panel could
      show._ _`volumeLine` returns null rather than a `$0.00/month` line when
      there is no volume: "$0" reads as "this costs nothing", which is the
      opposite of "we could not find out". `endpointHealth` distinguishes
      configured-but-unrouted from absent, because those need different actions
      (an env var versus a feature flag), and reports a missing video endpoint
      as a NORMAL state with the reason — motion submits fail loud rather than
      falling back, so the absence here is the same absence the submit path
      enforces._ _**Mounted 2026-09-12.** The video meter, the two endpoint
      blocks and the volume line read the auth-gated `/ready` detail through a
      new `client.generation.getReadiness()` — `/ready` and not `/health`
      because an endpoint id, a budget and a volume size are operator evidence._
      _**The kill switch became two.** It hit one hard-coded endpoint
      (`RUNPOD_COMFYUI_ENDPOINT_ID`), so there was no way to stop the video one:
      the service, the route and the client now take a `target`, defaulted to
      `image` because every caller that existed before the video endpoint meant
      that one, and silently repointing a control that STOPS CAPACITY is the
      worst possible change. "Not configured" names the env var for the target
      asked about, since the wrong variable sends an operator to fix something
      that was never the problem._ _Which button was pressed is read from the
      REQUEST, not the response — older API builds omit `target` entirely — and
      when the response names a DIFFERENT endpoint the card refuses to claim
      success and says to treat this one as still running._ _An absent video
      endpoint renders "there is nothing to stop" rather than a button that
      would 503: a button that always fails teaches the operator to ignore the
      card. 9 new page specs plus 5 on the service, 22 in the file, and
      **verified in chromium** — both meters, both endpoint blocks, the
      $35.00/month volume line, and arming one switch leaving the other
      unarmed._
- [x] **V.09.06** Playwright (chromium, `workers=1`, API mocked at the HTTP
      boundary): submit `wan22-i2v` with a fixture PNG, see phases, see the
      video card play (assert `readyState ≥ 2` on a fixture mp4 served by the
      mock), see the video meter move.
      `apps/isis/web/e2e/motion-runpod-dashboard.spec.ts`. _Partly done
      2026-09-12 — **stays `[ ]` for the submit leg, the phases and the meter**,
      each of which needs UI that is not mounted yet (V.09.02, V.09.03,
      V.09.05). **The `readyState` leg is done and RAN GREEN in chromium.**_
      _**This is the assertion nothing below a browser can make.** The unit
      specs pin the markup — `<video controls playsinline poster src>` — and
      jsdom has no media pipeline, so it cannot tell a working player from a
      `<video>` pointed at a 404. The test serves the REAL 17-frame fixture that
      `mp4-probe.spec.ts` cross-checks against ffprobe, as bytes rather than a
      data URL, and waits for `readyState >= 2` (HAVE_CURRENT_DATA) — which the
      browser reaches only after decoding a frame._ _It then asserts WHICH file
      decoded: `videoWidth` 64, `videoHeight` 64, `duration` 1.06 s. A
      `readyState` check alone would pass on any playable clip, including the
      wrong one._ _Run:
      `npx playwright test --project=chromium --workers=1     e2e/motion-runpod-dashboard.spec.ts`
      → **1 passed (5.6s)**, 2026-09-12. Dev server torn down afterwards and the
      port confirmed free with `lsof`, per the machine rules._ _**Closed
      2026-09-12** once V.09.02 and V.09.05 mounted what the other three legs
      needed. Four tests in the file now, all green in chromium: the clip that
      decodes (above), the motion controls, the two spend meters with both
      endpoint blocks and the volume line, and the SUBMIT leg — `wan22-i2v`
      chosen from the motion preset, a fixture PNG pasted as `start_image`, and
      the posted body asserted to carry the frame count the control DISPLAYED
      and the resolution NAME rather than pixels, then the phases appearing for
      the job that comes back._ _Two things only a browser found. Playwright
      matches `page.route` handlers in REVERSE registration order, so a
      catch-all registered last silently swallows every specific mock above it —
      it cost two blank-page failures before the pattern was clear, and both
      tests now register the catch-all FIRST with the reason written down. And
      the Extra Parameters box lives behind a collapsed `Advanced` disclosure:
      `inputValue()` reads it happily while `fill()` refuses, which is exactly
      the class of thing jsdom cannot notice._ _The phase fixture was wrong in a
      way worth recording: phases are NOT a `metadata.phases` map. `queued` and
      the total run come from timestamps, and the finer phases exist only once a
      worker reports `metadata.progressStage` — inventing a shape would have
      tested the test._ _Run:
      `npx playwright test --project=chromium --workers=1     e2e/motion-runpod-dashboard.spec.ts`
      → **4 passed (13.5s)**, 2026-09-12. Dev server torn down afterwards and
      the port confirmed free._
- [x] **V.09.07** One real-browser pass on the V.11.01 output (no new
      generation): screenshot the playing clip card into the evidence file; kill
      the Vite server (`lsof` check). **Done 2026-09-12, $0** — chromium against
      the live API: `readyState ≥ 2`, decoded `832×480` / `2.0625 s` matching
      `ffprobe`, and `currentTime` advanced 0 → 1.2023 s under `play()`, so the
      bytes decode AND move. Card reads
      `33f · 16fps · 832×480 · silent ·     ~$0.5226 · 375.4s · 528.3s cold start`.
      Found on the way: `/outputs` is backed by a separate service on :3002 that
      the dev recipe does not start, so it renders empty by configuration — the
      clip card is on `/jobs`. Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § V.09.07.

## V.10 Dev stack recipe additions

- [x] **V.10.01** Runbook `chroma-runpod-dev-stack.md` gains a "video" section:
      the second endpoint id, the video budget/rate vars, the volume S3 vars,
      `ffprobe` availability check, and the reminder that a single video job can
      cost more than the whole image day budget. _§2d in
      `docs/domains/isis/runbooks/chroma-runpod-dev-stack.md`. Every claim in it
      was checked against the code rather than written from the plan: the
      `endpoint list` subcommand exists (`runpod-provision.mjs:505`), the video
      ledger's Redis suffix really is `:video`
      (`runpod-cost-ledger.service.ts:186`), and `comfyui-video` in the
      endpoints desired state really carries the H100 `gpuIds` the rate check
      compares against._ _The `ffprobe` item is written as what it is: a
      CONVENIENCE, not a dependency. The API parses the MP4 boxes itself
      (`mp4-probe.ts`) precisely because `ffprobe` is silently absent on a slim
      image, so the section gives the install line and a cross-check command but
      says plainly that nothing in the API needs it — and carries the two
      caveats that make its numbers differ honestly from the parser's (average
      vs nominal fps on a `-shortest`-truncated track, measured 12.8 vs 16; WebM
      returns null because EBML is a different container)._ _One correction made
      while writing: the first draft said a `motion` fallback would fail because
      the image endpoint lacks the Wan weights and video packs. It does not —
      both endpoints run the same image off the same volume. The real reason,
      which is what `comfyui.service.ts:967` says, is VRAM: falling back sends a
      28 GB expert to a 24 GB pool and bills the OOM._
- [x] **V.10.02** `dev-stack-preflight.mjs`: asserts the video endpoint id,
      video rate matches the video endpoint's `gpuIds` (H100 → 0.001331; L40S →
      0.000486 if V.11.06 moves Wan), volume S3 credentials present (length
      only), `BUCKET_ENDPOINT_URL` host is the volume's S3 endpoint. Spec. _All
      four assertions in `scripts/isis/dev-stack-preflight.mjs:190-258`, spec'd
      in `dev-stack-preflight.test.mjs` ("video checks are skipped without an
      endpoint and all bind once it is set"), 6/6 green. Every video check is
      skipped entirely when `RUNPOD_COMFYUI_VIDEO_ENDPOINT_ID` is unset — the
      image stack has to stay usable on its own, and a preflight that fails over
      an optional endpoint teaches people to ignore it. The credentials are
      checked by LENGTH and the spec asserts the value never appears in the
      output. The rate check's real target is the dangerous mistake of copying
      the image rate: an H100 second costs ~4.3x a 4090 second, so the ledger
      would under-count by that factor and the budget would never fire — the
      spec pins exactly that case as a failure. Landed in `ab3ac18073e`
      alongside the fix to `expectedRateFor`, which had been broken for every
      pool id since the endpoint moved to GPU pools._
- [x] **V.10.03** `/health` reports both endpoints, both ledgers, volume size.
      Spec. _Built on `/ready`'s auth-gated `detail`, NOT on `/health` — a
      deliberate correction to the item, recorded here because it is a security
      decision and not a convenience. An endpoint id, a daily budget and a
      volume size are operator evidence; the rule `app.ts` already states and
      enforces is "A READINESS VERDICT IS PUBLIC AND ITS EVIDENCE IS NOT"
      (I6.13.d), and `/health` has no auth at all (`authMiddleware` is mounted
      on `/api/*`). `runpodChroma` already rode the gated `detail`, already
      masked the image endpoint id, and already refused to throw — so extending
      it kept all three properties instead of re-deciding them on a public
      route._ _`collectRunPodChromaReadiness()` in
      `apps/isis/generation-api/src/services/runpod-chroma-readiness.ts` now
      also returns `video` (masked endpoint id, `motionCatalogRoutable`, its own
      daily ledger) and `volume` (masked id, `sizeGb`, `dataCenterId`). The two
      ledgers are read independently through the same `readLedger()` helper, so
      a dead video ledger reports `{status:'error'}` on the video block alone
      and the image half still answers — spec'd. `video` is `null` when no video
      endpoint is configured, which is a normal complete state for the
      image-only stack, not a fault: a `motion` submit fails loud in that case
      rather than falling back (V.06.03), so the absence here is the same
      absence the submit path enforces._ _The volume comes from the checked-in
      `infra/runpod/volumes/desired-state.json`, never from a RunPod call —
      otherwise a RunPod outage becomes an Isis readiness failure. What it
      reports is what the repository INTENDS; `runpod-endpoint-drift-check.mjs`
      is what compares intent to reality. A relative path is searched upward
      from the working directory, the same way `readRepoJson` in the executor
      resolves the endpoints desired state — the API is started from the app
      directory as often as from the repo root, and a readiness field that
      silently went null because of cwd would be worse than absent. A missing or
      wrong-shaped file yields `null`, never an exception and never a partial
      guess. (First draft read an `ISIS_RUNPOD_VOLUME_DESIRED_STATE_FILE` env
      var directly; the conventions ratchet correctly rejected a new
      `process.env` read outside `libs/shared/config`, and the upward search is
      the better answer anyway.)_ _`runpod-chroma-readiness.spec.ts`, 12/12
      green: the video block null when unconfigured (and for an empty-string
      id), populated with its own distinct snapshot when set, error-isolated
      from the image ledger; the volume parsed from the REAL checked-in file
      (`ax0oj250j3`, 500 GB, EU-RO-1 — not a fixture, so a provisioner change
      that breaks this reader fails here instead of on a live `/ready`), found
      from a subdirectory via the upward walk, and null for both a missing file
      and a present file of the wrong shape; plus a test that serializes the
      whole payload and asserts no unmasked endpoint or volume id appears
      anywhere in it — masking that covered only the top-level field would be
      worse than none, because it would look done. `npx tsc --noEmit` on the
      app: clean._

## V.11 Live proof matrix (eight tiny clips, nothing more)

User decision 2026-09-11: live generations are kept to the minimum that proves
the implementation to a reasonable degree. What a live run uniquely proves is
(a) the model files on the volume load in the worker, (b) the node pack imports
on the real GPU image, (c) the transport (input via volume S3 / `images[]`,
output via `SaveVideo` → `images[]` → S3 → dashboard), (d) real cost numbers.
Wiring, modes, inputs and defaults are proved offline by V.06.06 and V.01.09. So
the matrix has one clip per distinct model-load / pack-import risk and zero
repeats. Rules for every clip:

- **Smallest legal size:** Wan 33 frames (4n+1) at 480p landscape; LTX 33 frames
  (8n+1) at 768×512; Animate on a 33-frame driving clip; matte / VFI / VSR on
  the 33-frame output of the first clip. Default quality settings otherwise (the
  defaults are what ships).
- **One warm session:** the matrix runs from a single script
  (`scripts/isis/motion-live-proof.mjs`) that submits the next job before the
  previous one completes so the worker never idles out (idle timeout 10 s);
  clips are ordered by model so each checkpoint is read from the volume once.
  Expect one cold start, two at most.
- **Each row records:** job id, RunPod job id, `delayTime`, `executionTime`,
  USD, cold/warm, GPU assigned, output sha256, duration, fps, resolution, audio
  yes/no, poster path. A failure is recorded with the worker's error text; the
  row stays `[ ]`; the workflow keeps `proof_level: validated`.
- **No re-runs for quality tuning.** If a default looks wrong, change it, pass
  V.01.09 again, and re-render ONLY that clip, once, with the reason written in
  the evidence row.

Proved live (8): T2V, I2V, Animate, SAM 3 track→VACE inpaint, BiRefNet matte,
GIMM-VFI, FlashVSR, LTX-2.3 t2v+audio. Proved offline only: `wan22-t2v`
`lightx2v_4step`, `wan22-i2v` `end_image`, Animate `replacement` + `relight`,
VACE `restyle`/`extend`/`outpaint`, standalone `sam3-video-track`, `ltx23-av`
`i2v`/`two_stage`/`audio_reference`, the `still-to-polished-clip` chain document
(its runner is proved by V.11.02's VFI→VSR two-step chain).

- [x] **V.11.01** `wan22-t2v`, 33 f, 832×480, defaults — the one standalone live
      clip, run first and alone. Proves cold start, Wan T2V pair + umt5 + VAE
      load, `SaveVideo` → `images[]` → S3 → dashboard, video ledger. Record the
      cold-start seconds and, for D-V2, the image endpoint's cold start after
      the rebuild. **Done 2026-09-12 — the first clip exists.** Isis job
      `bd345ee6`, RunPod `e87838c0-…-e2`, worker `b3vnt2h8obe53d`, **delayTime
      528 347 ms / executionTime 375 411 ms**, cold. The ledger first booked
      **$1.2029 and that was wrong** — the account balance moved about
      **$0.29**, because `delayTime` here was queue wait for a card, which
      RunPod does not bill. Billing is execution-only now and the wait is
      reported separately; the real charge is ≈ $0.284, the A100 80 GB tier.
      `wan22-t2v_00001_.mp4` 211 885 B sha256 `31e44a9c…`, and `ffprobe`
      independently confirms h264 832×480 16 fps 33 frames 2.0625 s — every
      stamped fact matches. Provenance bundle `prov_bbcfcdf9601fd29a`, watermark
      applied. **Four attempts; the first three got no card and cost $0** (the
      C.12.17 queue-phase deadline retried them for free). Execution ran 7.5×
      its catalog sticker per frame, which is V.11.05's to rewrite. **The video
      endpoint's cold start is 528 s.** D-V2 turns on the IMAGE endpoint's cold
      start after the rebuild, which is a different number and is measured
      separately — see the C.11.01-rebuild row. **Correction 2026-09-13:** the
      clip travelled INLINE — `base64` in `images[]`, 211 885 B, well under the
      10 MiB body cap — so the `S3` leg named above was not exercised by this
      clip or by any V.11 clip; the volume's `outputs/` prefix is empty and the
      stock worker cannot write to it as configured (V.12.05). Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § V.11.01.
- [x] **V.11.02** The warm-chained session (one invocation of
      `motion-live-proof.mjs`, seven clips, in this order): 1. `wan22-i2v` from
      a C.11.01 still, 33 f, `fit 480p` (I2V pair load, image input path). 2.
      `gimm-vfi-interpolate ×2` → `flashvsr-upscale ×2` on the V.11.01 clip **as
      a two-step chain** (proves the V.06.05 runner, the cupy and triton
      imports, `GetVideoComponents` audio passthrough, both packs' model
      folders). 3. `birefnet-video-matte` on the V.11.01 clip (decode one webm
      frame in the evidence step and assert real alpha, not a black matte). 4.
      `sam3-track-then-vace` on the V.11.01 clip, text prompt naming a present
      object, `inpaint` mode (SAM 3 video nodes + VACE 14B load in one clip; the
      mask overlay is saved too, so tracking is inspectable). 5. `wan22-animate`
      `animation` mode, reference = the C.11.01 still, driving = the V.11.01
      clip (Animate + clip\*vision\*h + ONNX pose/face models + preprocess
      pack). 6. `ltx23-av` `t2v`, 33 f, 768×512, audio on (LTX-2.3 + Gemma 24
      GB + audio VAE load; assert an audio track with the V.05.05 probe and hear
      it in the browser). Each of the six numbered outcomes gets its own
      evidence row; V.11.02 is marked only when all six rows exist (a failed one
      stays open as its own re-run, once). **\*2026-09-13, $0: the two
      undiagnosed failures had no log because the CAPTURE was broken, not
      because the worker was gone.** RunPod's worker-log route is
      `text/event-stream` — it replays from the worker's first line at roughly
      eight frames a second and never closes — so both harnesses'
      `await response.text()` could never resolve, and every failure row said
      "log fetch timed out" (the v1102 summary carries it verbatim for stages 2b
      and 6). Measured live against a worker on `2lezocymx2rgot`: `?tail=N` is
      honoured (the last N lines, then live), `Last-Event-ID` and `?since=` are
      not, and a recycled worker answers 404 in about three seconds.
      `scripts/isis/runpod-worker-log.mjs` now streams the tail and stops on a
      2.5 s quiet gap or a 20 s cap, reporting a capped read as truncated; 7
      `node --test` cases run it against a real SSE `node:http` server (paced
      replay split mid-frame, a never-quiet stream, a socket dropped mid-replay,
      404/500/silent), and the CLI pulled 12 tail lines from the live worker in
      5.3 s. Both harnesses call it. **Owed and unchanged:** the `ltx23-av`
      re-run (graph fixed) and first real attempts at `flashvsr-upscale` and
      `wan22-animate` — they will carry the worker's traceback this time. Each
      needs a card in EU-RO-1 and together roughly $0.6–1.0 of execution; about
      $2.0 of the $1.50–2.60 the user approved has been spent (balance $13.50 →
      $10.24 with ≈$1.13 of it volume rent), so this waits for the user's go
      rather than assuming it.\_ **\*Approved and run 2026-09-13 07:32–07:58Z,
      one invocation, one worker (`bkeiqpovpvuuy6`, RTX PRO 6000 Blackwell
      Server Edition), $0.78 of GPU measured off the settled balance ($10.0905 →
      $9.2772 = $0.813, $0.037 of it volume rent; a reading 90 s after the last
      job showed only $0.608 — RunPod posts charges late).** Rows: **2a**
      `gimm-vfi-interpolate` COMPLETED, exec 25.4 s, `2a-…-26a1a57a.mp4` 214 932
      B, 65 f at 32 fps (re-run only to feed 2b). **6** `ltx23-av` COMPLETED,
      exec 304.9 s, `6-…-93a142c8.mp4` 292 869 B — ffprobe: h264 1024×576 25 fps
      33 f **plus an AAC track of 62 frames**, so the audio path is proved.
      **5** `wan22-animate` COMPLETED, exec 338.2 s, warm, `5-…-e9fca11a.mp4`
      139 748 B, h264 832×480 16 fps 33 f — the same minimum shape that killed
      the worker on 2026-09-12 rendered cleanly when submitted alone after
      everything else had settled; the earlier death's cause remains
      unestablished and did not recur. **2b** `flashvsr-upscale` FAILED again
      (exec 71.0 s) — **and this time the worker log was captured**
      (`v1102-rerun/worker-bkeiqpovpvuuy6-1789285991353.log`): the model loaded
      from `/comfyui/models/FlashVSR-v1.1/`, tile 1/8 started, and Triton raised
      `RuntimeError: Failed to find C compiler` while compiling its NVIDIA
      driver module for the pack's sparse-sage int8 attention. The runtime image
      ships no gcc. Fixed in the Dockerfile (gcc + libc6-dev, fatal smoke check)
      — build `a96a0123` (commit `299b763f408`); one re-run of 2b after it is
      the last row. The 825 s `delayTime` on the first stage was placement, not
      boot: the container was created at 07:46:15 and the 25 s clip was done
      inside the same minute.\_ _**Closed 2026-09-13 08:34Z — the sixth row
      exists.** Build `a96a0123` failed its own new smoke check
      (`Python.h not found under /usr/include/python3.12`: the venv runs
      Ubuntu's python3.12 and Triton's driver module is a CPython extension), so
      `python3.12-dev` joined gcc; build `79351a92` (commit `47a74b751`) passed
      — `C toolchain: gcc 13.3.0; Python.h at /usr/include/python3.12`, 19/19
      goldens, smoke exit 0 — and both endpoints released it. Re-run
      `--only 2a,2b` on worker `k7lblqd18yoqac`: **2a** 22.7 s warm ($0.03),
      **2b `flashvsr-upscale` COMPLETED, exec 57.9 s, warm**,
      `2b-flashvsr-upscale-0-c4645d50.mp4` 1 117 573 B, ffprobe h264
      **1664×960** (exactly 2x of 832×480), 65 frames at the catalog's default
      16 fps. The pack, the Triton kernel, the model folder symlink and the
      chain runner are all proved. Every one of the six numbered outcomes now
      has a rendered row; the 2026-09-12 rows for 1, 3 and 4 stand._
- [x] **V.11.03** Budget refusal for the VIDEO ledger, for real, $0: set
      `ISIS_RUNPOD_VIDEO_DAILY_BUDGET_USD` below today's ledger, submit, confirm
      429 + the disabled dashboard state; restore. **Done 2026-09-12, $0** — 429
      `RUNPOD_DAILY_BUDGET_EXCEEDED` with `ledger video`, video-only headers,
      and an image submit accepted alongside it (the two budgets are
      independent). Studio `studio-motion-budget-block` names the video budget
      and says image jobs are unaffected; submit disabled, then restored. Spend
      was seeded on a throwaway ledger prefix, the real key verified absent
      before and after, and zero RunPod calls were made. The drill found and
      fixed three defects — the C.12.17 retryable flag being discarded by
      `classifyError`, `/ready`'s evidence being typed under a `detail` key the
      route does not emit (which had blanked the dashboard's entire video half,
      kill switch included), and `checkedAt` never being returned. Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § V.11.03.
- [x] **V.11.04** Kill switch for the video endpoint, for real, $0: workers-max
      → 0, submit, confirm `IN_QUEUE` then cancellation by the API timeout;
      restore workers-max 1; drift check green on both endpoints. **Done
      2026-09-12, $0** — engaged from the dashboard (arm + confirm), video
      `workersMax 0` with the image endpoint untouched, restored by a PATCH that
      changed 1 of 19 fields, and `no drift (2 endpoints checked)`. **The
      `IN_QUEUE` half of this item was a wrong premise:** RunPod queues nothing
      against a paused endpoint, it refuses `/run` with
      `409     ENDPOINT_PAUSED`, so there is no queued job to cancel — and no
      backlog to stampede when the ceiling goes back up. `/health` stayed at
      `inQueue 0` and both ledgers at zero. The drill found that **every
      `motion` workflow was being validated against the IMAGE worker image's
      node classes** and refused before dispatch (which also blocked
      V.11.01/V.11.02), and that a paused endpoint surfaced as "Unexpected
      RunPod provider error"; both fixed. Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` § V.11.04.
- [x] **V.11.05** Rest-state check + RunPod billing view vs both ledgers; write
      the measured `estimated_seconds_per_megapixel_frame` for the eight
      rendered workflows into their catalog files and set their `proof_level` to
      `rendered`; replace the sticker rows in both cost tables with measured
      numbers; commit. _**Partly done 2026-09-12; stays `[ ]` because only FIVE
      of the eight workflows rendered.** Done: rest state verified on both
      endpoints (0 running / 0 queued / `workersMin 0`, so no standing spend);
      the billing comparison, which is the finding — the ledger booked $1.2029
      for V.11.01 and the account moved ~$0.29, because `delayTime` was queue
      wait and RunPod does not bill it (fixed, billing is execution-only now);
      measured rates and `proof_level: rendered` written into `wan22-t2v`,
      `wan22-i2v`, `sam3-track-then-vace`, `birefnet-video-matte` and
      `gimm-vfi-interpolate`, each citing its RunPod job id; and the video cost
      table's sticker rows replaced for those five. **Owed:** the three
      workflows V.11.02 could not render (`flashvsr-upscale`, `ltx23-av`,
      `wan22-animate`), and the cold-start figure, which is NOT readable off
      `delayTime` — that field is dominated by queue wait on a starved endpoint
      (528 s video, 1 315 s image, almost none of it booting). Isolating it
      needs a warm session's total charge against the sum of its execution
      times._ _**2026-09-13: two of the three owed rates are measured and
      written** — `ltx23-av` 15.6647 s/MP-frame (304.901 s, 33 f at 1024×576,
      job `fe0b6f92-…-e2`) and `wan22-animate` 25.6611 s/MP-frame (338.185 s, 33
      f at 832×480, job `2fb8e666-…-e2`), both `proof_level: rendered`,
      `cost_calibration: measured`, cost table rows replaced. **The cold-start
      figure now has a bound:** the worker's own log shows the container created
      at 07:46:15Z and the first clip (25 s of execution) complete within that
      same minute, so container-start-to-first-prompt is under about 20 s with
      FlashBoot; the 825 s `delayTime` in front of it was placement. **And the
      real per-second charge is measured:** $0.776 of GPU for 739.4 s of
      execution = $0.00105/s on the RTX PRO 6000 Blackwell Server Edition — the
      ledger's configured $0.002400/s overstates that card 2.3x (it bills the
      dearest card in the pool list by design). Wait for the balance to settle
      before reading it: the first reading, 90 s after the last job, was $0.17
      short. Still owed: `flashvsr-upscale` (image fix built, one re-run)._
      _**Closed 2026-09-13.** `flashvsr-upscale` measured at 0.5579 s per OUTPUT
      megapixel-frame (57.933 s for 65 frames at 1664×960, job `5e0c3687-…-e2`)
      and written with `proof_level: rendered`; all eight rendered workflows now
      carry `cost_calibration: measured` rates citing their RunPod job ids, and
      the cost table has no sticker left among them. Rest state after the last
      run: 0 queued, 0 running, `workersMin 0`, spend $0.049/h (the volume).
      Billing view vs ledger: the ledger bills the dearest card in the pool list
      ($0.002400/s) by design; the settled balance says the card that actually
      ran bills $0.00105/s, so ledger figures are a 2.3x upper bound on this
      endpoint — recorded in the cost model, not changed, because placement is
      not reported and the bound is the point._
- [x] **V.11.06** _(conditional, only if the user asks after seeing V.11.05's
      numbers)_ L40S comparison: re-run V.11.01's clip once on L40S and decide
      whether Wan moves to a cheaper endpoint. Leave `[ ]` unless asked.
      _2026-09-13: not asked; stays `[ ]` by its own wording. For the record,
      the V.03.04 GPU review already rejected every 48 GB card (an L40S cannot
      hold LTX-2.3 or `wan22-animate` beside their encoders), so a Wan-only L40S
      endpoint would be a third endpoint, not a swap._ _**Closed by decision
      2026-09-13: the user chose NOT to run it.** Reason recorded: the V.03.04
      review rejected every 48 GB card for LTX-2.3 and Animate, so an L40S
      comparison would mean a third, Wan-only endpoint for a saving the measured
      card ($0.00105/s on the RTX PRO 6000 Blackwell) makes small. Reopen only
      if a Wan-only product line appears._

## V.12 Follow-ups (visible, out of this scope)

- [x] **V.12.01** SAM 3.1: re-check monthly whether ComfyUI-RMBG or ComfyUI-SAM3
      grows a loader for `sam3.1_multiplex*`; until then record "no supported
      pack (checked <date>)" — never approximate by renaming the 3.1 file to
      `sam3.safetensors`. _No supported pack (checked 2026-09-13): ComfyUI-RMBG
      `main` is still `58f1947a` (2026-08-21, the pinned SHA) and ComfyUI-SAM3
      `main` is still `de0ff5d2` (2026-05-19, the pinned SHA); neither tree has
      a path or a loader mentioning `sam3.1` or `multiplex`. Next check due
      around 2026-10-13._ _2026-09-14: superseded by A.01.09, whose build
      a350cf59 removed the vendored SAM 3 packs after SAM 3.1 on core nodes
      rendered both re-renders._
- [x] **V.12.02** LTX-2.3 IC-LoRA union control (depth/pose/edges, 0.65 GB
      ungated) and the camera LoRAs as `motion` control inputs. _2026-09-13,
      listed not pulled: `Lightricks/LTX-2.3-22b-IC-LoRA-Union-Control` 0.65 GB
      ungated (facts section) fits the 141.6 GB headroom trivially and could
      reach `models/loras/` for $0 over S3 (C.02.09). What blocks it is design,
      not space: a control graph for `ltx23-av` — the depth, pose and edge
      preprocessors are in the image (controlnet_aux), but the IC-LoRA
      conditioning path through ComfyUI 0.34.0's LTX nodes has not been read,
      and whether the camera LoRAs ship as a `camera` enum is a scope choice.
      Blocked on: the user's go on the control set; it would then be proved
      offline like every V.08 mode._ _**Built 2026-09-13 as Union +
      Motion-Track, per the user's choice; live clips pending.** `ltx23-av`
      gained `control` (none | canny | depth | pose | motion_track),
      `control_video`, `motion_tracks` (Lightricks' JSON: a list of tracks, each
      a list of `{x, y}` per frame) and `control_strength`. canny/depth/pose:
      `LoadVideo` → `GetVideoComponents` → the named preprocessor
      (`CannyEdgePreprocessor` / `DepthAnythingV2Preprocessor` /
      `DWPreprocessor`, the VACE settings) → `ImageScale` to the output size →
      `ImageFromBatch` cut to `length` → `LTXAddVideoICLoRAGuide`, with
      `LTXICLoRALoaderModelOnly` loading the union-control weight on the model
      and `LTXVCropGuides` stripping the reference tokens before decode — the
      wiring of `LTX-2.3_ICLoRA_Union_Control_Distilled.json`. motion_track
      renders the JSON with `LTXVDrawTracks` and loads the motion-track weight.
      Which source feeds `ImageScale` is a map lookup
      (`control_source_map[control]`); everything else is `_condition`-gated,
      and the passthrough lanes were checked: with `none` the guider reads
      `LTXVConditioning`, the concat reads the empty latent and the decoder
      reads `LTXVSeparateAVLatent`, byte-identical to the goldens. Needs
      `Lightricks/ComfyUI-LTXVideo` @ `15d09abb` in the image (build `ea83e467`)
      — kornia is its one hard dependency. Goldens for canny, depth, pose,
      motion_track and distilled+canny; ltx golden spec 21/21; the video
      inventory lists the three pack classes and the three weights (0.65 GB
      union, 0.33 GB motion-track, on the volume over S3). Owed: one live clip
      per mode._ _**Rendered live 2026-09-13, one clip per mode.** Video
      endpoint `2lezocymx2rgot`, worker `si1kjzlg2l02nk`, every clip t2v with
      `speed_mode=distilled`, 1024x576, 33 frames plus an audio track (ffprobe),
      seed 1213. Canny, depth and pose were guided by the committed Wan T2V clip
      from V.11.01 (in `v1101/`); `motion_track` by one drawn left-to-right
      track. Execution seconds and execution-only USD at 0.001647 per second:
      canny 504.8 s and 0.83 USD (job `4cf31ae7`, the first on the worker, so it
      paid the 22B model load); depth 28.5 s and 0.05 USD (`9d74ef10`); pose
      23.8 s and 0.04 USD (`6381c9e1`); `motion_track` 120.4 s and 0.20 USD
      (`114ae2e6`). Queue delay was 23 to 32 minutes each with no free GPU, not
      billed. Frame 16 of each is in `v12-proofs/controls-frame16-grid.png`:
      canny and depth keep the source layout (grate left, boat right of centre);
      pose, given a source with no people, composes freely, as an empty skeleton
      guide should; `motion_track` draws the prompted red car. The clips are
      committed under `v12-proofs/`, one folder per mode._ _2026-09-14:
      superseded. LTX-2.3 retired from the catalog and manifest under A.01.04
      once LTX-2.5 had rendered; its files leave the library when that item
      closes._
- [x] **V.12.03** LTX-2.3 distilled 1.1 (46 GB) as a `speed_mode` for `ltx23-av`
      — a volume decision (space) before a catalog one. _2026-09-13: the volume
      decision is the user's. `ltx-2.3-22b-distilled-1.1.safetensors` 46.15 GB
      (facts section) fits the 141.6 GB headroom and would leave about 95 GB; it
      is a loader-pod pull (V.02.04's path, not an S3 PUT). Blocked on: that go.
      The catalog half afterwards is a `speed_mode` enum on `ltx23-av` in the
      `wan-speed-mode` pattern._ _**Built 2026-09-13 as the LoRA, per the user's
      choice; live clip pending.** `ltx23-av` gained `speed_mode` (default |
      distilled): distilled inserts `LoraLoaderModelOnly` with
      `ltx-2.3-22b-distilled-lora-384-1.1.safetensors` at 0.5, swaps
      `BasicScheduler` for `ManualSigmas` carrying Lightricks' 8-step list
      (`1.0, 0.99375, 0.9875, 0.98125, 0.975, 0.909375, 0.725, 0.421875, 0.0`),
      forces both CFGs to 1 and the sampler to `euler_ancestral_cfg_pp` — the
      `LTX-2.3_T2V_I2V_Single_Stage_Distilled_Full` example verbatim. The
      scheduler choice is a map lookup on the sampler's `sigmas` input
      (`sigma_source_map[speed_mode]`), so the unused scheduler is simply
      dropped by its `_condition`. Golden `ltx23-av.t2v.distilled.golden.json`;
      default renders unchanged. The 7.61 GB LoRA (`Lightricks/LTX-2.3` @
      `5948be4c`, sha `f5d4953f…`) is being PUT to `loras/` over S3 ($0, no
      loader pod). Owed: one live clip._ _**Rendered live 2026-09-13.** Job
      `a9b9e575` on the video endpoint, fresh worker `7x1o7i41c4y2zw`, t2v with
      `speed_mode=distilled` and no control, 1024x576, 33 frames plus audio
      (mean -31.5 dB, peak -17.7 dB, so not silent), seed 1213. Execution 392.2
      s and 0.65 USD at 0.001647 per second, including the cold model load;
      queue delay 36.9 minutes, not billed. The request carried the default 30
      steps, CFG 3 and euler, and the renderer replaced them as designed: the
      committed distilled golden shows `ManualSigmas` with the 8-step list, both
      guider CFGs at 1, `euler_ancestral_cfg_pp` and the distilled LoRA at 0.5.
      Frames 0, 16 and 32 (`v12-proofs/distilled/frames-0-16-32.png`) show the
      prompted wooden boat at a dock at dawn, stable across the clip. The four
      control clips of V.12.02 also ran in distilled mode on a warm worker at
      23.8 to 120.4 s._ _2026-09-14: superseded. LTX-2.3 retired from the
      catalog and manifest under A.01.04 once LTX-2.5 had rendered; its files
      leave the library when that item closes._
- [x] **V.12.04** Wan2.2 Fun Control / Fun Camera / S2V (speech-to-video) and
      InfiniteTalk — each is another 30–70 GB; list, do not pull. _**Listed
      2026-09-13 from the anonymous HF API (sizes are the LFS byte counts;
      nothing pulled).** Headroom on the volume is 141.6 GB (358.4 of 500 GB
      with C.12.02's row), so any ONE of the 14B pairs fits and no two do. All
      full precision, all in `Comfy-Org/Wan_2.2_ComfyUI_Repackaged` (Apache-2.0,
      ungated) under `split_files/diffusion_models/` unless noted: **Fun Control
      14B** `wan2.2_fun_control_high_noise_14B_bf16` 28.58 GB + `…low_noise…`
      28.58 GB = 57.16 GB (a 5B single-file `wan2.2_fun_control_5B_bf16` is
      10.00 GB); **Fun Camera 14B** `wan2.2_fun_camera_high/low_noise_14B_bf16`
      29.58 GB × 2 = 59.16 GB; **Fun Inpaint 14B** 28.58 GB × 2 = 57.16 GB (5B:
      10.00 GB); **Fun VACE 14B** `wan2.2_fun_vace_high/low_noise_14B_bf16`
      34.68 GB × 2 = 69.36 GB; **S2V 14B** `wan2.2_s2v_14B_bf16` 32.59 GB plus
      `split_files/audio_encoders/wav2vec2_large_english_fp16.safetensors` 0.63
      GB = 33.22 GB (ComfyUI 0.34.0 has the S2V nodes natively; the
      `audio_encoders` folder is already mapped). The fp8-scaled halves that sit
      beside each of these are excluded by D-V5. **InfiniteTalk is different in
      kind:** it is a Wan **2.1** I2V add-on, not a 2.2 model — its README pins
      `Wan-AI/Wan2.1-I2V-14B-480P` and `TencentGameMate/chinese-wav2vec2-base`,
      neither of which is on the volume (the volume carries only 2.2 experts),
      and no pack in the image loads it (it needs kijai's WanVideoWrapper, a
      rebuild). Weights: `MeiGen-AI/InfiniteTalk` (Apache-2.0)
      `single/infinitetalk.safetensors` 9.95 GB,
      `comfyui/infinitetalk_single.safetensors` 2.71 GB,
      `comfyui/infinitetalk_multi.safetensors` 2.71 GB; kijai's fp16 conversions
      `Kijai/WanVideo_comfy/InfiniteTalk/Wan2_1-InfiniTetalk-Single_fp16.safetensors`
      5.13 GB and `…-Multi_fp16` 5.12 GB (that repo carries no license tag). So
      InfiniteTalk costs ~32 GB of Wan 2.1 base plus the encoder plus a
      node-pack rebuild before its own 2.7–10 GB, which makes it the last of the
      four, not the first. Pulling any of these is a volume decision (space) and
      a loader run, both the user's._ _2026-09-14: S2V and HuMo-17B are scoped
      in E.03.04–E.03.05 as a bake-off in the Hetzner library (option B replaced
      the volume question); Fun Camera stays listed as E.03.06's fallback and
      InfiniteTalk stays listed only._
- [ ] **V.12.05** Webhook completion + direct S3 output are already the
      transport for video (D-V4); retrofit the image endpoint to the same path
      (C.12.06) once V.05 is proven. _**2026-09-13: V.05 is proven on the INPUT
      leg and on the API-side fetch, and the OUTPUT leg has never run.** The
      volume's `outputs/` prefix is empty (listed through its S3 API); the
      bucket env was never injected into either live template, because
      `runpod-provision.mjs` does not honour `envFromEnvironment`, both
      templates were created in the console, and a git-integration template's
      env is unreadable through GraphQL and REST alike. The stock worker's
      uploader also targets a month-named bucket (C.12.06), so the per-job
      outputs key shape that `volumeKeyOf` expects is a convention nothing
      writes. Every V.11 clip rode `images[]` inline under the 10 MiB body.
      Nothing to retrofit until the worker-side uploader exists; that work
      belongs with C.12.06._ _2026-09-18, board tag: nothing to retrofit until
      the worker-side uploader of C.12.06 exists, as the note above records._
      `blocked:upstream`
- [ ] **V.12.06** Retention policy for `outputs/` on the volume beyond the 7-day
      sweeper (archive to MinIO, then delete). _2026-09-13: nothing lands under
      `outputs/` today (V.12.05), so there is no data to archive; the sweeper
      (V.05.03) already refuses every prefix but `inputs/` and `outputs/`.
      Revisit once the output leg writes to the volume._ _2026-09-18, board tag:
      there is no data to archive until V.12.05 makes the output leg write to
      the volume._ `blocked:upstream`

## A.00 Arsenal expansion: phase control, volume and pull order (added 2026-09-13)

- [x] **A.00.01** Grow `ax0oj250j3` to **1024 GB** with
      `runpod-provision.mjs volume update ax0oj250j3 --size 1024 --yes`
      (`--dry-run` first; the grow-only guard reads the live 500). Sized by the
      arsenal footprint table (peak 798.36 GB ÷ 0.8). Irreversible; the user's
      go is the 2026-09-13 instruction "expand the storage volume as needed to
      accommodate them all". Record the read-back size, the tiered monthly cost
      ($71.20) and the timestamp in the evidence file (`## A.00`), in
      `infra/runpod/volumes/desired-state.json` (`sizeGb`, `monthlyUsd`,
      `sizeHistory`) and in the manifest's `volume.sizeGb` (the lint reads that
      field); lint stays green. _Done 2026-09-13 09:55:31Z. `volume get` before
      → size 500; `--dry-run` printed
      `PATCH     /networkvolumes/ax0oj250j3 {"size":1024}`; `--yes` answered
      size 1024; read back at 09:55:33Z through the script and again through raw
      REST → 1024, EU-RO-1, name unchanged; the GraphQL account snapshot lists
      the volume at 1024. Tiered cost $71.20/month (was $35.00). Desired-state
      (`sizeGb`, `monthlyUsd`, `sizeHistory`, `pricingNote`) and the manifest's
      `volume.sizeGb` updated in the same commit; `--strict` lint after: 50
      artifacts, 367.17 GB of 1024 GB, 64.1 % headroom, 0 errors. The account's
      `currentSpendPerHr` read $0.761 right after the grow — that is another
      session's live worker (chroma endpoint: 1 running worker, 1 job in
      progress; video endpoint: 1 throttled worker, both at 09:57Z), not the
      volume, whose share is $0.0989/hour. Evidence `## A.00`._ _2026-09-13
      later: the 1024 GB size is **transitional** under option B; L.06.05
      deletes this volume once the Hetzner library is download-verified and the
      400 GB cache is proven._
- [x] **A.00.02** Balance runway before any pull. At 1024 GB the volume alone is
      $0.0989/hour; the 09:40Z balance of $9.13 lasts about 3.8 days, and
      RunPod's docs say a volume left at $0 "may eventually be terminated and
      its data cannot be recovered". Blocked on: the user topping the account up
      (payment details are typed by a person, never by an agent; Auto-Pay stays
      OFF by the C.04.01 decision). Re-read `account` after the top-up and write
      the balance here. No A.01–A.05 pull starts before this is checked — a
      half-pulled arsenal on a deleted volume is the failure this item exists to
      prevent. _2026-09-13 later: during the migration both volumes exist
      ($0.136/hour), so the top-up matters more, not less; L.06.01 does not
      create the cache volume before this is checked._ _**Checked 2026-09-13
      15:26Z.** GraphQL `myself`: `clientBalance` $17.94 (up from $9.13 at
      09:40Z while spending, so the account was topped up), `currentSpendPerHr`
      $0.132 (the 1024 GB volume plus the library-seed CPU pod), `spendLimit`
      $80. With the 400 GB cache volume added the migration runs at about
      $0.171/hour, roughly 4.4 days of runway; once L.06.05 deletes `ax0oj250j3`
      the cache alone is $0.039/hour, about 19 days. The old volume's deletion
      therefore should not wait long after L.06.04._
- [x] **A.00.03** Pull order and path, fixed here so no session improvises: (1)
      **S3 PUT for everything under ~3 GB** (C.02.09's
      `runpod-volume-s3-put.mjs`, $0, download on the Mac, `shasum -a 256`
      against the hash in the row first): SAM 3.1, Depth Anything 3, every
      Civitai LoRA, the LTX-2.5 IC-LoRAs and upscalers, the SCAIL-2 LoRAs, the
      SeedVR2 VAE; (2) **one loader-pod run** (V.02.04's recipe, CPU pod
      EU-RO-1, ~86.7 MB/s measured, so ~430 GB ≈ 85 min ≈ $0.09 of pod time —
      _superseded 2026-09-13 by option B: pulls stream through the pod to
      Hetzner, whose measured upload is 37.8 MB/s with 8 parts, so ~430 GB ≈ 3.2
      h ≈ $0.19_) for every Hugging Face heavyweight and the three Civitai
      checkpoints — the loader already handles `source: civitai` rows with
      `CIVITAI_API_KEY` (C.02 pulled UnCanny and Photonic that way); (3) nothing
      is retired until its replacement has rendered (A.01.04, A.01.06, A.02.07,
      A.02.08). Retire-before-pull is **not** required at 1024 GB — the peak
      fits — so the order is about cost and proof, not space. Record wall clock
      and pod cost as V.02.04 did. _2026-09-13 later, superseded in part by
      option B: the destination of every pull is the **Hetzner library**, not
      the volume. The loader leg becomes L.01.04's `library-pull`; the "download
      on the Mac and S3 PUT" leg uploads to Hetzner, not to RunPod's volume API.
      Files reach the cache only through L.04's sync._ _**Done 2026-09-14
      06:00Z.** Every A-row went to the Hetzner library by library-pull pods (no
      Mac download leg was needed: the loader streams Hugging Face and Civitai
      sources straight into multipart uploads). Six pods from 21:51Z to 06:06Z,
      0.49 USD of pod time at 0.06/hour, recorded pod by pod with result files
      under the A.00 evidence section. Three loader defects surfaced and were
      fixed on the way: a dropped source read threw away the whole upload (Range
      resume), a timed-out source open was never retried, and a stalled part had
      five quick attempts (now twelve, with a landed object recognised after a
      Complete errors); the start loop also reruns a killed loader. Library: 117
      objects, 813.38 GB of the 900 GB alarm line. One row is not in it: the
      CyberRealistic Z-Image bf16 file, whose Civitai download answers 403 to
      the account's key (A.03.02). Nothing was retired before its replacement
      rendered._
- [x] **A.00.04** Manifest rows for every A-item **before** any byte moves
      (V.02.02's pattern): Hugging Face rows carry the 40-hex revisions from the
      2026-09-13 facts block and the LFS oid as `sha256`; Civitai rows carry
      `modelVersionId`, `fileId`, the version API's SHA-256, `gated: true`,
      `auth: CIVITAI_API_KEY`; shared files use `sharedBy` and add no bytes
      (`ae.safetensors`, `qwen_3_4b.safetensors`, umt5, `clip_vision_h`). Add
      `geometry_estimation` to the lint's `ALLOWED_TOP_FOLDERS` with a comment
      naming the Depth Anything 3 core node that reads it, and a `--strict` lint
      run green with every row present (that is the 22.0 % headroom the 1024 GB
      size buys). Add an `id` prefix per family (`ltx25-`, `wan22-animate2-`,
      `seedvr2-`, `sam31-`, `zimage-`, `da3-`, `hidream-o1-`, `klein4b-`,
      `qwen-image-`, `scail2-`, `civitai-`) so the inventory page groups them.
      _2026-09-13 later: each A-row also gets its family ids (L.02.01), and its
      library key is `isis/models/` plus `destPath` (L.01.01)._ _**Done
      2026-09-13 21:50Z: 62 rows, 112 in all, 825.94 GB; strict lint 0 errors, 0
      warnings; cache 238.71 GB pinned plus LTX-2.5 92.19 GB of 380 GB
      allowed.** Sizes and SHA-256 were read again from the Hugging Face tree
      API at each pinned revision and from the Civitai version API, and exact
      Civitai byte counts from a one-byte ranged download (the version API
      reports kilobytes). Reading the ComfyUI templates before writing rows
      changed four things: LTX-2.5 loads the plain video VAE (the conv variant
      is not taken) and a second Gemma 4 E2B encoder; HiDream-O1 loads a Gemma 4
      E4B encoder (the facts block said none); the Z-Image controlnet patches
      live in the model patches folder, which the lint now allows beside the
      geometry estimation folder; both encoders come from Comfy-Org gemma-4 at
      bf16, Apache-2.0, because the templates ship int8 and fp8 builds. The
      Animate-2 and SCAIL-2 templates name a bf16 Wan VAE; per A.01.05 the
      volume's Wan 2.1 VAE is tried first, so no row. Shared files gain families
      and sharers rather than duplicate rows (umt5, CLIP vision H, the Wan 2.1
      VAE, the Flux ae, Qwen3 4B, SAM 3.1, the Qwen-Image encoder and VAE, the
      SeedVR2 VAE). Fifteen new families, one pinned (SAM 3.1); the Chroma set
      and the Wan LoRA pairs join their pinned families. Gated rows: the LTX-2.5
      repos answered 403 until the user accepted the three licence gates on
      2026-09-13; the rows carry auth HF ACCESS TOKEN, and the loader now sends
      it (it never had) while the provisioner injects it only when a gated row
      is in the manifest. One open risk: the CyberRealistic bf16 file's download
      link answered 403 to a ranged probe, so its size is the API's kilobyte
      figure and the pull will refuse loudly if that is wrong. Commit below._
- [ ] **A.00.05** Evidence and proof policy:
      `docs/agents/isis-chroma-runpod-evidence.md` gains `## A.00`–`## A.05`;
      every live render records `delayTime`, `executionTime` and settled USD
      through the C.11 harness (`runpod-catalog-run.mjs`) or
      `motion-live-proof.mjs`, and flips its catalog entry to
      `proof_level: rendered` with a measured rate. One live render per new
      model and per LoRA (user decision 2026-09-13); estimate about 30 renders,
      stills $0.01–0.08 each on the image endpoint, clips $0.10–0.35 each on the
      video endpoint, roughly $3–5 all in — ask before spending it, as C.11 did.
- [x] **A.00.06** The dashboard's volume line is flat-rate
      (`runpod-video-panel-utils.ts` `volumeLine`:
      `sizeGb × pricePerGbMonthUsd`), so at 1024 GB it shows $71.68 where RunPod
      bills $71.20. Make it tier-aware (first 1000 GB at 0.07, the remainder at
      0.05) with a spec case at 1024 and one at 500 (unchanged $35.00). Small,
      but the panel is what an operator reads; it must not disagree with the
      invoice. _2026-09-13 later: moot at the 400 GB cache, where the flat $0.07
      rate is exact; it matters again only if the cache ever grows past 1000 GB.
      Stays `[ ]` as the record of that condition._ _**Done 2026-09-13 anyway,
      so the condition needs no record.** `volumeLine` now calls
      `tieredVolumeMonthlyUsd`: the first 1000 GB at the file's rate, the rest
      at 0.05. Spec cases: 1024 GB is 71.20 (the invoice; a flat multiply said
      71.68), 500 GB stays 35.00, 400 GB 28.00, 1000 GB 70.00, 2000 GB 120.00;
      `runpod-video-panel-utils.spec.ts` 14/14._

## A.01 Video tier: LTX-2.5, Wan2.2-Animate-2, SeedVR2, SAM 3.1

- [x] **A.01.01** LTX-2.5 rows and pull (81.91 GB): the dev transformer, the
      Gemma 4 with-proj encoder, the video VAE (and the `-conv` variant only if
      the ComfyUI 0.32+ LTX-2.5 template loads it — read the template before the
      row, do not pull both on a guess), the audio VAE, both latent upscalers,
      the distilled LoRA (`speed_mode` parity with V.12.03), the Ingredients
      IC-LoRA and the pixel-spatial-upscaler IC-LoRA. The repos are
      `gated: auto`: confirm `runpod-volume-loader.py` sends `HF_ACCESS_TOKEN`
      for gated rows (it has never had to; the LTX-2.3 rows are ungated) and
      that the token's account has accepted the LTX-2.5 licence gate — the
      acceptance click is the user's, not an agent's. Blocked on: A.00.02.
      _**Done 2026-09-14.** All ten ltx25 rows (92.19 GB: the dev transformer,
      the Gemma 4 with-projection and E2B encoders, the plain video VAE, which
      the template loads instead of the conv variant, the audio VAE, both latent
      upscalers, the distilled LoRA and both IC-LoRAs) are in the Hetzner
      library with their manifest sha256, per the arsenal pull's result file.
      The loader sends the token for gated rows and the provisioner injects it
      only when a gated row is present; the user accepted the three licence
      gates. The transformer needed the loader's Range resume: two earlier
      attempts lost it mid-stream._
- [x] **A.01.02** `ltx25-av` catalog workflow, cloned from `ltx23-av` and
      re-pointed: Gemma 4 loader, LTX-2.5 nodes per the 0.32+ template, the
      duration predictor exposed as an optional input, native multishot as a
      `shots[]` input (one prompt per shot, continuity held across cuts),
      `speed_mode: distilled` on the 8.90 GB LoRA. `content_policy: sfw_only`
      (A.04.01). Proved offline by the static validator and the build's ComfyUI
      validator (`proof_level: validated`), then one live t2v clip with audio
      and one multishot clip → `rendered`, rates written to the catalog.
      `ltx23-av` stays until A.01.04. _2026-09-14, offline half done; stays open
      for the live clips. The catalog entry has t2v and i2v in the templates'
      two stages (half-size pass, 2x latent upscale, refine on the template's
      four sigmas), flf2v in one full-size stage with first and last frame
      guides, and distilled speed mode through the distilled LoRA on the 8-step
      sigma list. The first pass's 30 steps and CFG 3 video / 7 audio come from
      Lightricks' ltx-pipelines, since no ComfyUI 2.5 template runs the
      non-distilled model; the distilled LoRA strength 1.0 is the pipelines'
      default, not from a 2.5 graph, and the live render should confirm it. Not
      built: the duration predictor (the node exists but needs a 3.8 MB duration
      head with no manifest row), native multishot (no ComfyUI node takes
      per-shot prompts; the model card treats it as prompt writing), control
      modes (no 2.5 union-control row). SFW only, validated, sticker cost 0.98
      USD scaled from the LTX-2.3 measured rate._ _2026-09-14, live clip: t2v on
      the distilled schedule, 49 frames at 768 by 448 with audio (RunPod job
      32e9b0f5, 400.6 s on a cold worker, 0.6598 USD): the picture follows the
      prompt, but the audio track is nearly silent (mean -61.8 dB), so audio is
      recorded as not proven. ltx25-av is rendered with a measured rate whose
      default-shape scaling passes the 900 s cap (flagged in the evidence).
      Stays open for a warm or default-shape clip with audible audio; multishot
      has no ComfyUI surface._ _2026-09-14, audible audio: a t2v clip prompted
      with loud drumming (6bb72e9d, 49 frames at 768 by 448, distilled, 414.4 s
      cold, 0.6826 USD) has loud percussive audio (mean -17.2 dB, evenly spaced
      hits in the spectrogram), so LTX-2.5 audio is proven; soft ambient prompts
      came out nearly silent on three clips, recorded in the catalog note. Warm
      distilled jobs measured 3.23 s per megapixel-frame for Ingredients. Stays
      open only for a default-schedule clip at the default shape, whose cold
      scaled rate passes the 900 s cap and which the approved spend did not
      cover._ _2026-09-14, default job, on the user's go: t2v on the default
      schedule at the default 121 frames of 1280 by 704 (70664678, 440.8 s on a
      cold worker, 0.7259 USD) finished well inside the 900 s cap, with loud
      audio (mean -11.4 dB, peak 0.0 dB, possibly clipped) and the prompted
      drummer on a club stage. The catalog rate is now that job's 4.0423 s per
      megapixel-frame (headline 0.7259 USD, preset matched), replacing the
      49-frame cold figure that had put the default job past the cap. Stays open
      for the two parts that cannot be built today: the duration predictor (its
      3.8 MB head has no manifest row) and a `shots[]` multishot input (no
      ComfyUI node takes per-shot prompts)._ _**Done 2026-09-15.** Both parts
      are built. `shots[]` takes 2 to 4 shots and composes them into the single
      chronological paragraph Lightricks' prompting guide prescribes, joined by
      the guide's hard cut, match cut or dissolve phrasing. Setting both `shots`
      and a prompt of the caller's own is refused. `auto_duration` wires
      ComfyUI's `LTXVDurationPredictor` to the published duration head (new
      manifest row, library copy verified by sha256, cache synced) into every
      node that sizes the clip, with `length` as the upper bound; ingredients
      mode refuses it. The worker was rebuilt (3acf2224) so the snapshot offers
      the head. Live, through the API as the operator on the approved spend: job
      442dd359 (three shots, auto duration, 121 frames at 1280x704, 500.2 s
      cold, 0.8238 USD at the ledger rate) shows the three prompted shots in
      order, with cuts at 2.21 s and 3.83 s and loud audio. The predicted length
      equalled the 121-frame cap, so sizing below the cap is not demonstrated
      (recorded in evidence A.01.02). Two refusals before GPU time were fixed on
      the way: the prompt requirement and the pre-rebuild snapshot. Specs:
      workflows lib 1173, the new transform spec, prompt requirement 3._
- [x] **A.01.03** Ingredients mode on `ltx25-av`: a `reference_sheet` image
      input (characters, props, location on a black background, no text), looped
      into the static control video the IC-LoRA expects, Lightricks' recipe
      (768×448, 121 frames, 24 fps, strength 1.0) as the default shape; plus the
      pixel-spatial-upscaler IC-LoRA as an `upscale: pixel_x2` tail. One live
      clip each. _2026-09-14, offline half done; stays open for the two live
      clips. Ingredients follows the model card (768 by 448, at least 121
      frames, 24 fps, strength 1.0, black background, the reference-sheet prompt
      form): the sheet is padded black, repeated to the frame count and applied
      through the IC-LoRA guide. Lightricks' own example workflow disagrees with
      the card (strength 1.3, 241 frames) and loads the 2.3 file, so the card
      won. The pixel x2 tail uses the pixel spatial upscaler IC-LoRA as
      Lightricks' 2.5 video-to-video example wires it: the decoded clip as the
      reference, a 2x latent, the first pass's audio frozen, eight steps at
      CFG 1._ _**Done 2026-09-14.** Ingredients (452cf724, 121 frames at 768 by
      448, distilled, 134.5 s warm, 0.2215 USD) from a reference sheet of a
      woman, her face, a yellow handbag and a greenhouse: the clip carries her
      identity, braids, coat, trousers and the handbag into the greenhouse. The
      pixel x2 tail (61c74f24, a 49-frame 768 by 448 t2v doubled to 1536 by 896,
      187.5 s warm, 0.3088 USD) runs and doubles the frame; on that smooth
      stylised clip a down-and-up resample scores 37.1 dB against it, so its
      detail gain is not established, which the evidence says. Both clips' soft
      ambient audio is nearly silent._
- [x] **A.01.04** Retire LTX-2.3 after A.01.02 has rendered: remove the rows
      `ltx23-22b-dev`, `ltx23-spatial-x2`, `ltx23-temporal-x2`,
      `gemma3-12b-it-bf16`, `ltx23-distilled-lora-1.1`,
      `ltx23-ic-lora-union-control`, `ltx23-ic-lora-motion-track` (80.38 GB)
      from the manifest, delete the files over the volume's S3 API (add a
      guarded `rm` to `runpod-volume-s3-put.mjs`: `models/` prefix only, refuses
      unless the manifest row is already gone, needs `--yes`), delete the
      `ltx23-av` catalog entry and its goldens in the same commit (an entry
      pointing at absent weights is a fabricated capability), lint, evidence.
      V.12.02 and V.12.03 close as superseded when this does. If the 2.5
      Union-Control IC-LoRA has appeared by then, it replaces V.12.02's 2.3-only
      control set under A.01.02, not here. _2026-09-13 later: under option B the
      retirement deletes the object from the Hetzner library and evicts the
      family from the cache through L.04; the volume-side `rm` helper is not
      built._ _2026-09-14, retirement, catalog and manifest half, after LTX-2.5
      rendered t2v with audible audio, Ingredients and pixel x2 (A.01.02,
      A.01.03): the `ltx23-av` workflow, its eight goldens and golden spec,
      registry and taxonomy entries, motion caps, Studio preset and video
      inventory entries are gone, and the seven rows (80.37 GB) and the ltx23
      family are out of the manifest (100 rows, 707.29 GB, 28 families), with
      the register regenerated. Specs that used it as the real sfw_only or
      two-family example now use ltx25-av, wan22-t2v or wan21-vace-edit; the
      V.11 live-proof harness's LTX stage runs LTX-2.5 distilled. Capability
      given up: LTX canny, depth, pose and motion-track control (no LTX-2.5
      union-control row exists); Wan VACE still offers depth, pose and canny.
      The ltx-av-options renderer module is now used by no catalog workflow.
      V.12.02 and V.12.03 are superseded (noted on them). Stays open for
      deleting the seven files from the Hetzner library, which waits on the
      user's confirmation._ _**Done 2026-09-14 20:41Z.** On the user's go, the
      seven LTX-2.3 files (80,373,783,346 B) are deleted from the Hetzner
      library by exact key, and an 8.72 GB partial Gemma 3 download left on the
      cache volume by an interrupted pull is deleted with them. A re-listing
      shows nothing left (evidence A.05.03)._
- [x] **A.01.05** Wan2.2-Animate-2 rows and pull (65.58 GB): base and distilled
      bf16 from `Comfy-Org/Wan-Animate-2`; umt5 and `clip_vision_h` are
      `sharedBy` rows (oids proved identical); the bf16 Wan VAE only if the
      template refuses the volume's `wan_2.1_vae`. Blocked on: A.00.02. _**Done
      2026-09-14.** Base and distilled Animate-2 bf16 are in the library with
      their manifest hashes; umt5 and CLIP vision H are shared rows (the
      family's closure is 78.46 GB with them). No bf16 Wan VAE row: the
      Animate-2 workflow loads the volume's Wan 2.1 VAE and the build's ComfyUI
      validator accepted that graph, so the template did not refuse it. Whether
      it renders correctly is A.01.06's live clip._
- [x] **A.01.06** `wan22-animate-2` catalog workflow: driving video and
      reference image in, **no** `OnnxDetectionModelLoader` /
      `PoseAndFaceDetection` / `DrawViTPose` stage, a `viewpoint` text input,
      `speed_mode: distilled` (10 steps, no CFG, euler). Validated, then one
      live clip at the V.11 minimum shape and one at the shape that once killed
      a worker (896-class); `wan22-animate` stays until both have rendered, then
      Animate-1's two rows (35.99 GB) and the `wan22-animate` entry retire by
      the A.01.04 procedure. `content_policy: adult_ok`. _2026-09-14, offline
      half done; stays open for the two live clips. Built from the distilled
      Animate-2 template: 10 steps, the LCM sampler (not euler as written
      above), CFG 1, shift 5, reference image and driving clip in, no pose or
      face preprocessing stage, output at the clip's rate with its audio. Only
      the distilled schedule exists: the base template needs the lightx2v I2V
      distill LoRA, which has no manifest row, and the template has no viewpoint
      conditioning. The volume's Wan 2.1 VAE and fp16 umt5 stand in for the
      template's bf16 VAE and fp8 encoder. The family also pulls the 32.79 GB
      base row, which no graph loads. The Studio now asks for a length in frames
      for graphs whose rate follows the clip; seconds times an unknown rate had
      written length 0. Adult content allowed, validated, sticker cost._
      _2026-09-14, decision: the unused Animate-2 base bf16 is out of the
      wan22-animate2 cache family (user chose to keep it in the library but stop
      syncing it), in a library-only family no workflow requires; an Animate-2
      sync now copies 45.67 GB instead of 78.46 GB. Adding a lightx2v I2V
      distill LoRA row later would let a base schedule use it._ _2026-09-14: the
      lightx2v I2V distill LoRA row this note names is E.03.01._ _2026-09-14,
      live clip at the minimum shape: 33 frames at 482 by 854 requested, 480 by
      848 out (88646ae9, 244.1 s cold, 0.4021 USD), the reference identity
      preserved; the driving clip showed the same person, so it proves the
      graph, not motion transfer. Stays open for the 896-class clip and the
      Animate-1 retirement._ _2026-09-14, the 896-class clip: 33 frames at 512
      by 896 exactly (37528cd3, 253.5 s cold, 0.4174 USD, under the 275 s the
      catalog rate predicts), with the reference woman following the driver.
      Both clips have rendered, so `wan22-animate` may now retire; stays open
      for that retirement (A.05.03)._ _2026-09-14, retirement, catalog and
      manifest half: the `wan22-animate` workflow, its two goldens and golden
      spec, registry and taxonomy entries, motion caps, Studio preset and video
      inventory entry are gone; the specs that used it as an example now use
      Animate-2 or SCAIL-2, and the V.11 live-proof harness's Animate stage runs
      Animate-2. Animate-1's transformer and relight LoRA rows and the
      wan22-animate family are out of the manifest (107 rows, 787.66 GB, 29
      families), and the shared umt5, Wan VAE and clip_vision_h rows no longer
      list it; the register is regenerated. The snapshot spec excuses the
      Animate-1 transformer the recaptured build still offers, and fails once a
      later snapshot drops it. The YOLOv10m and ViTPose rows (1.30 GB) that only
      Animate-1's pose pass loaded stay as a library-only family no workflow
      requires, and the WanAnimatePreprocess pack stays in the image until a
      rebuild. Stays open for deleting the two retired files from the Hetzner
      library (35.99 GB), which waits on the user's confirmation._ _**Done
      2026-09-14 20:41Z.** On the user's go, Animate-1's transformer
      (34,549,787,368 B) and relight LoRA (1,436,673,432 B) are deleted from the
      Hetzner library by exact key; the cache held neither. The two pose models
      Animate-1 alone loaded stay in the library as an unrequired family until
      someone says otherwise (evidence A.05.03)._
- [x] **A.01.07** SeedVR2 rows and pull (23.76 GB): 3B fp16, 7B fp16 and the VAE
      from `Comfy-Org/SeedVR2`. Node names come from the object-info snapshot of
      the next build (native since 0.28.0), never from memory. _**Done
      2026-09-14.** 3B fp16, 7B fp16 and the EMA VAE are in the library with
      their manifest hashes, and the node names used by the workflows are the
      core SeedVR2 classes in the snapshot recaptured from build b5376e6b._
- [x] **A.01.08** `seedvr2-upscale` motion workflow (7B, video endpoint) beside
      `flashvsr-upscale`, and a `seedvr2_3b` option on C.12.02's still-upscale
      tail beside RealESRGAN x2 (image endpoint, 6.78 GB). One live clip and one
      live still; write both rates. RealESRGAN's row stays until the still tail
      has rendered on SeedVR2 3B, then retires. _2026-09-14, offline half done;
      stays open for one live clip and one live still. The third-party SeedVR2
      templates needed a node pack the worker does not have, so both are built
      on the int8 SeedVR2 templates, which use only the core SeedVR2 nodes the
      snapshot lists, with the fp16 rows substituted (7B for the clip upscaler,
      3B for the still tail; the core loader's default dtype keeps fp16). Clip
      upscaler: one step, CFG 1, tiled encode and decode, keeps the source rate,
      audio and bit depth, the FlashVSR caps; its sticker borrows FlashVSR's
      rate and probably understates. Still tail: the Chroma upscale enum is now
      none, x2 or seedvr2_3b, at 2x for the same output limit as RealESRGAN; the
      existing goldens render byte-identical. Families are per workflow, so the
      two Chroma workflows now require the SeedVR2 3B family, pinned beside
      RealESRGAN (pinned closure 246.00 GB) so an eviction can never stall a
      Chroma still behind its re-sync. RealESRGAN stays._ _2026-09-14: the still
      tail rendered live on SeedVR2 3B (9de9bb72, 2048 square, 79.2 s, 0.0348
      USD; no banding in the file, 3,963 distinct colours in a smooth patch).
      Stays open for the clip and RealESRGAN's retirement._ _2026-09-14, live
      clip: SeedVR2 7B upscaled a 33-frame 480 by 832 clip 2x to 960 by 1664
      (07f38e2a, 129.1 s with the model load, 0.2127 USD); seedvr2-upscale is
      rendered with a measured per-output-megapixel-frame rate. Both proofs are
      now in; stays open only for RealESRGAN's retirement (A.05.03)._
      _2026-09-14, retirement, catalog and manifest half: the x2 tail is gone
      from chroma-txt2img and chroma-img2img (upscale is none or seedvr2_3b; a
      job naming x2 is refused at render with the options it may use, tested),
      both require only chroma-core and seedvr2-3b, the x2 golden is deleted and
      the others render unchanged; the RealESRGAN row and its pinned family are
      out of the manifest (109 rows, 823.65 GB, 30 families, 10 pinned, pinned
      closure 245.93 GB), the register is regenerated and the image endpoint
      inventory no longer requires it. A stale spec that expected no cache when
      only the volume variable was unset (the manifest has named the cache
      volume since L.06.05) now also hides the manifest. Stays open for deleting
      the file from the Hetzner library and the cache volume, which waits on the
      user's confirmation._ _**Done 2026-09-14 20:41Z.** On the user's go,
      `RealESRGAN_x4plus.pth` (67,040,989 B) is deleted from the Hetzner library
      and, with its hash sidecar, from the cache volume, by exact key; the cache
      database marks the realesrgan family evicted (evidence A.05.03)._
- [x] **A.01.09** SAM 3.1 on core nodes: row
      `checkpoints/sam3.1_multiplex_fp16.safetensors` (1.75 GB, S3 PUT); switch
      `sam3-video-track`, `sam3-track-then-vace`, `sam3-segment` and
      `sam3-segment-inpaint` from the ComfyUI-SAM3 / ComfyUI-RMBG vendored nodes
      to `SAM3_Detect`, `SAM3_VideoTrack`, `SAM3_TrackToMask`; validated, then
      one live re-render of `sam3-video-track` and one of `sam3-segment`. Only
      after those render: drop ComfyUI-SAM3 (`de0ff5d2`) and RMBG's `sam3/`
      import from the image (a rebuild; the pycocotools and dangling-symlink
      fixes become dead weight) and close V.12.01 as superseded. The
      `sam3/sam3.safetensors` and `sam3.pt` rows (6.9 GB) retire with the packs.
      _2026-09-13, offline half done; stays open for the two live re-renders and
      the pack removal. All four graphs now load SAM 3.1 through the core
      checkpoint loader and run the core detect, video-track and track-to-mask
      nodes (core in ComfyUI 0.34.0, the version on the worker). Inputs with no
      core equivalent were removed rather than left ignored: the start frame and
      direction on video track, the track frame on track-then-VACE; the core
      node's object cap and detect interval were added. All four are validated,
      not rendered. The snapshot predates the SAM 3.1 row, so its one combo
      value is excused by name in the snapshot spec, which fails once a
      recaptured snapshot lists it._ _2026-09-14: sam3-segment re-rendered live
      on SAM 3.1 core nodes (4f43f8b2; mask is the subject's silhouette, cut-out
      alpha 0 on the background and 255 on the subject) and is rendered with
      measured cost. Stays open for the sam3-video-track clip and the pack
      removal._ _2026-09-14, live clip: sam3-video-track on SAM 3.1 core nodes
      (129e7f2e, 33 frames, mask aligned on the named object; a first run with a
      prompt naming nothing in the clip returned a false positive at the default
      threshold, recorded). Both re-renders are in; stays open for the pack
      removal rebuild and the old SAM 3 rows' retirement._ _2026-09-14, pack
      removal and rows: ComfyUI-SAM3 and ComfyUI-RMBG's SAM 3 still node (with
      pycocotools, the sam3 folder, its symlink and path key) are out of the
      image, and the two SAM 3 rows and their pinned family are out of the
      manifest (98 rows, 9 pinned families, pinned closure 239.03 GB). Build
      a350cf59 (commit 440d66abc) completed and auto-released to both endpoints;
      its smoke fails the build if a removed class registers again, the
      recaptured snapshot has none of them, and a live sam3-segment on the new
      image (270f413b, 0.0081 USD) returned a mask identical to the earlier SAM
      3.1 run. V.12.01 is superseded. Stays open for deleting the two files
      (6.90 GB) from the Hetzner library and the cache volume, which waits on
      the user's confirmation._ _**Done 2026-09-14 20:41Z.** On the user's go,
      `sam3/sam3.pt` and `sam3/sam3.safetensors` (6,899,922,873 B) are deleted
      from the Hetzner library and, with their hash sidecars, from the cache
      volume; the cache database marks the sam3 family evicted (evidence
      A.05.03)._

## A.02 Image tier: Z-Image, HiDream-O1, klein 4B, Qwen-Image (video endpoint), SCAIL-2, licence swaps

- [x] **A.02.01** Z-Image rows and pull (33.77 GB): `z_image_bf16`, `qwen_3_4b`
      (also klein 4B's), `ae.safetensors` as a `sharedBy` row, the base
      Fun-Controlnet-Union 2.1 and the Turbo Fun-Controlnet-Union
      2.1-2602-8steps. Confirm the folder the ComfyUI Z-Image controlnet
      template reads (`controlnet/` or `model_patches/`) before the row — the
      lint allowlist follows the template, not a guess. Blocked on: A.00.02.
      _**Done 2026-09-14.** Z-Image base bf16, Qwen3 4B, both Fun-Controlnet
      union patches and the shared Flux ae are in the library with their
      manifest hashes. The controlnet template loads its patch from
      `model_patches/`, confirmed before the row, and the worker's model path
      file now lists that folder (the patch loader offers both files in the
      recaptured snapshot)._
- [ ] **A.02.02** `zimage/` catalog category on the image endpoint:
      `zimage-txt2img` (base, CFG and negative prompt), `zimage-txt2img-control`
      (canny / depth / pose / tile through `controlnet_aux` and Depth Anything
      3, union strength and end-step inputs), `zimage-img2img`,
      `zimage-inpaint`, each with the C.12.01 `loras[]` pattern; a `checkpoint`
      enum offering the base and the two Civitai Turbo finetunes (A.03.02), with
      the Turbo union and 8 steps selected automatically for the Turbo ones.
      Measure VRAM at 1024² and 2048² on a 24 GB card (the C.12.19
      `maxBatchPixels` guard applies). `content_policy: adult_ok`. Validated,
      then one live still per workflow and per checkpoint. _2026-09-14, offline
      half done; stays open for the VRAM measurement and the live stills. A new
      zimage category on the image endpoint holds text-to-image, control (canny,
      depth through the core Depth Anything 3 nodes, pose, tile), img2img and
      inpaint, translated from the ComfyUI Z-Image templates at workflow
      templates tree aaac56dd (img2img and inpaint have no upstream template and
      reuse the Chroma graphs with the Z-Image sampler values). The checkpoint
      enum offers the base model, CyberRealistic Turbo and the Turbo AIO; a
      Turbo choice switches the steps, CFG, negative prompt and union patch
      through declared per-option data the renderer already reads, no new code.
      The union node has no end-step input, so an end fraction below 1 splits
      sampling into two passes, the second without the patch. Option policy for
      every checkpoint and LoRA is checked against the manifest licence strings
      by a spec. All validated, not rendered; the Workflows page does not list
      the zimage category yet._ _2026-09-14, live stills (evidence A.05.02):
      base text to image (9ba69352, 121.6 s cold with load), control with Depth
      Anything 3 depth (742ff7f7, 77.0 s, layout follows the source), img2img
      (398aa014, 24.2 s) and inpaint (b0b870e0, 23.8 s); all four workflows
      rendered with measured cost. The control render returned nudity the
      default prompt did not ask for (recorded). Stays open for the VRAM
      measurement at 1024 and 2048 square and the CyberRealistic checkpoint
      still (early access)._ _2026-09-15, VRAM and fit measured (evidence
      A.02.02, on the approved spend): the base checkpoint on an NVIDIA L4 (22
      563 MB) rendered 1024 square (20f079cc, 150.8 s cold, 2.56 s/it, no
      out-of-memory line). At 2048 square (e8575edb, latent overridden in the
      harness) it sampled without running out of memory at 13.27 s/it until the
      image endpoint's 300 s cap stopped it at step 23 of 25, so 2048 cannot
      complete on that card inside the cap. ComfyUI logs no peak allocation at
      INFO, so the measurement is fit and time, not a peak-GB figure. Stays open
      only for the CyberRealistic still (early access ends 2026-09-18T21:57Z)._
- [x] **A.02.03** HiDream-O1-Image Dev row and pull (16.37 GB, `checkpoints/`);
      `hidream-o1-txt2img`, `hidream-o1-edit` (instruction),
      `hidream-o1-personalize` (reference images with the layout and skeleton
      conditioning inputs the pipeline exposes). No external encoder or VAE
      rows. `content_policy: sfw_only`. Validated, then one live still each.
      _2026-09-14, offline half done; stays open for the live stills and one
      decision. Text to image (28 steps, CFG 1, 2048 square default, the model's
      eleven trained resolutions), instruction edit (one source, the template's
      4 MP rescale switched on so output size stays bounded) and personalize
      (two to ten references at a trained resolution, a pose skeleton counting
      as one reference, as upstream documents). Layout conditioning is not
      offered: it is a pipeline argument no ComfyUI node exposes. Image
      endpoint: the graphs load only the 15.24 GiB checkpoint. Decision needed:
      the Gemma 4 E4B encoder (14.92 GiB) is loaded only by the template's
      optional prompt-refine step, which passes an empty prompt when the model's
      reply is not the expected JSON and still reports success, so no workflow
      offers it; its row now has no workflow, and while it sits in the
      HiDream-O1 family every HiDream sync pulls it for nothing. SFW only,
      validated, not rendered._ _2026-09-14, decision: the E4B encoder is out of
      the hidream-o1 cache family (user chose to keep it in the library but stop
      syncing it). It sits alone in a library-only family no workflow requires,
      so a HiDream sync now copies 16.37 GB instead of 32.39 GB; its register
      row stays SFW only, as HiDream-O1's encoder._ _**Done 2026-09-14.** One
      live still each on the image endpoint (evidence A.05.02): text to image
      (RunPod job 2cc428f6, 2048 square, the sign reads "HiDream-O1-Image
      release", 82.0 s including the checkpoint load, 0.0360 USD), edit
      (a96fdd37, 42.9 s, 0.0188 USD) and personalize with two references
      (1de1d17b, 39.0 s, 0.0171 USD). All three are rendered with measured cost
      calibration._
- [x] **A.02.04** FLUX.2 klein 4B rows and pull (8.09 GB plus the shared
      encoder); `klein4b-txt2img` and `klein4b-edit` (multi-reference, up to the
      count the template accepts). `content_policy: sfw_only`; the catalog never
      offers an encoder swap. Validated, then one live still each. _2026-09-14,
      offline half done; stays open for the live stills. Text to image and edit
      (one or two references, the template's limit) follow the distilled klein
      subgraphs, because the volume's file is the distilled model: euler, 4
      steps, CFG 1, 1024 square. SFW only, no checkpoint, encoder or LoRA
      inputs. The per-job caps now cover the FLUX.2 empty latent and scheduler,
      which no cap read before. Validated, not rendered._ _**Done 2026-09-14.**
      One live still each (evidence A.05.02): text to image (58eb154b, 1024
      square, 73.1 s including the model load, 0.0321 USD) and edit (91dbd849,
      6.0 s warm, 0.0026 USD), which turned the linen dress red and changed
      nothing else. Both rendered with measured cost._
- [x] **A.02.05** Qwen-Image family rows and pull (106.32 GB) and the routing it
      forces: a `heavy_image` category (or an `endpoint: video` field on a
      `chroma`-style category — pick one and write the rule into
      `ledgerKindForCategory`) so `qwen-txt2img` (typography, native 2K),
      `qwen-edit` (up to three references) and `qwen-edit-control` (InstantX
      union and inpaint) render on the **video** endpoint and bill the video
      ledger while returning stills. `content_policy: sfw_only`. Validated, then
      one live still each, cost recorded against the video rate. Blocked on:
      A.00.02, and on the pull order (it is the largest single family, pulled
      last). _2026-09-14, offline half done; stays open for the live stills. The
      rule is a category: `heavy-image` is a video-endpoint category in the one
      endpoint routing function (ledger, dispatch, timeout, node-class inventory
      and chain billing all call it), and the catalog schema, taxonomy, video
      inventory and smoke test know it. Text to image from the Qwen-Image 2512
      template (50 steps, CFG 4, 1328 square, the template's default and its
      seven sizes, not 2K), edit from the 2511 template (one to three images, 40
      steps) and edit-control with the InstantX union mode (20 steps, CFG 2.5,
      the no-LoRA values of the sibling templates, since the Lightning LoRA has
      no row; takes a ready control map because the template's Lotus depth model
      has no row either) and the InstantX inpainting mode. A spec resolves the
      real catalog entries to the video ledger and inventory. Sticker costs at
      the video rate, SFW only, validated, not rendered._ _2026-09-14: the
      Qwen-Image-Edit 2511 Lightning row is E.04.01, which adds it as a speed
      mode on `qwen-edit` and `qwen-edit-control`._ _2026-09-14, live still on
      the video endpoint: qwen-txt2img at 1328 square (b94bedff, 373.3 s
      including loading 57 GB of weights, 0.6148 USD, billed on the video ledger
      as routed). Stays open for qwen-edit and qwen-edit-control._ _**Done
      2026-09-14.** qwen-edit with one reference (c432e401, 282.5 s including
      swapping in the Edit 2511 transformer, 0.4652 USD) changed the dress to a
      denim jacket and kept the woman and the scene. qwen-edit-control in union
      mode (93050b7b, 295.5 s cold, 0.4867 USD) ignored a full-length figure's
      canny map under the default portrait prompt; with a prompt describing the
      map (fc2678f9, 23.3 s warm, 0.0383 USD) the output's edges lie on the
      map's, and the prompt's description now says so. Inpaint (7df56a13, 77.5 s
      at 1536 square, 0.1277 USD) repainted a red leather jacket inside a SAM
      3.1 mask. Both workflows are rendered with measured cost at the video
      rate; two and three references are validated only._
- [x] **A.02.06** SCAIL-2 rows and pull (35.25 GB; umt5 and the Wan 2.1 VAE
      shared); `scail2-animate` on the video endpoint: reference character(s),
      driving video, optional replacement target, the DPO and relight LoRAs as
      toggles. `content_policy: adult_ok`. Validated, then one live clip (single
      character) and one multi-character clip. After A.01.06 and this have both
      rendered, decide which is the default animation route and record why; both
      stay. _2026-09-14, offline half done; stays open for the two live clips
      and the routing decision. Built from the SCAIL-2 character replacement
      template's first segment, non-turbo path (the turbo path needs the same
      unrowed lightx2v LoRA): 40 euler steps, CFG 5, shift 5, replacement or
      animation mode, SAM 3.1 tracking up to four people in the reference and
      the clip paired left to right, the DPO LoRA as a toggle and the relight
      LoRA chained after it as a toggle (no template loads relight, so that
      wiring is by analogy). Default length 33, since 81 frames would pass the
      900 s video timeout. Adult content allowed, validated, sticker cost._
      _2026-09-14: the lightx2v LoRA the turbo path needs is E.03.01._
      _2026-09-14, live clip, one character in animation mode at 480 by 832, 20
      steps (dc178886, 417.1 s cold, 0.6870 USD): new frames that follow the
      driving pose (26.2 dB mean PSNR against the driver, not a copy). Stays
      open for the multi-character clip and the routing decision._ _**Done
      2026-09-14.** Two characters (8140f060, 832 by 480, 33 frames, 20 steps,
      358.0 s, 0.5896 USD): the reference held two different women, the driver
      two copies of one clip, and the output puts both reference women in the
      driver's scene and poses in left-to-right order, so transfer to a
      different character is shown. Routing decision: Animate-2 is the default
      animation route for one performer, SCAIL-2 the route for more than one
      character or for replacement. Why: Animate-2 measured 18.2 s per
      megapixel-frame on its 10-step distilled schedule against SCAIL-2's 31.7 s
      at half its 40-step default, and its 81-frame default fits the 900 s cap
      where SCAIL-2 has to stop at 33 frames; SCAIL-2 is the only graph that
      pairs several characters with several performers. Both stay, and the
      Studio preset notes say which is for what._
- [x] **A.02.07** Depth Anything 3 swap (licence fix): row
      `geometry_estimation/depth_anything_3_mono_large.safetensors` (1.34 GB, S3
      PUT, Apache-2.0); repoint every graph whose depth preprocessor is
      `controlnet_aux`'s `DepthAnythingV2Preprocessor` (the motion control
      graphs and A.02.02's) to the core Depth Anything 3 node; validated, one
      live re-render of one depth-controlled workflow; then remove the
      `Depth-Anything-V2-Large` row (CC-BY-NC-4.0) and file. The volume must not
      carry a non-commercial weight once its replacement renders. _2026-09-13,
      offline half done; stays open for the live re-render and the V2 row's
      removal. The LTX-2.3 depth mode and the VACE depth control now run the
      core Depth Anything 3 load, inference and render nodes (mono, V2-style
      near-white depth). The worker's model path file gains the geometry
      estimation folder (and the model patches folder A.02.02 needs), without
      which the loader lists nothing; it ships with the A.05.01 build.
      Composition and mandala graphs are not RunPod catalog workflows and were
      left alone._ _2026-09-14: the live re-render is done:
      zimage-txt2img-control with control depth ran the core Depth Anything 3
      nodes (742ff7f7, evidence A.05.02) and the output keeps the source's
      layout. Stays open for the Depth-Anything-V2-Large row and file removal._
      _2026-09-14, manifest half: the row is gone (110 rows, 823.71 GB; the
      controlnet-aux family keeps DWPose and Depth Anything 3), the register is
      regenerated, and no RunPod catalog graph loads the V2 weight (only the
      non-RunPod composition and mandala graphs name the small V2 checkpoint).
      The endpoint licence gate still denies the V2 file by name. Stays open for
      deleting the file from the Hetzner library, which waits on the user's
      confirmation._ _**Done 2026-09-14 20:41Z.** On the user's go ("proceed on
      all"), the `depth_anything_v2_vitl.pth` file (1,341,395,338 B) is deleted
      from the Hetzner library by its exact key; the cache volume held no copy.
      A re-listing shows nothing left (evidence A.05.03)._
- [x] **A.02.08** Drop RMBG-2.0: remove the `RMBG/RMBG-2.0/model.safetensors`
      row (0.88 GB, non-commercial without a BRIA agreement, and the model that
      fails C.12.20) and the file; remove `rmbg-2.0` from every matting enum
      (the three BiRefNet rows stay); C.12.20 closes as moot with a note
      pointing here. _2026-09-13, manifest half done: the row and its family are
      gone (111 rows, 825.06 GB, 29 families, 10 pinned, pinned closure
      unchanged at 238.71 GB since the family was never pinned), no matting
      option or preset offers it, the RMBG-only resolution input is removed, and
      the register is regenerated. Stays open for the file deletion from the
      library and the cache, and C.12.20's note._ _**Done 2026-09-14 07:54Z.**
      On the user's instruction ("delete as planned", after weighing keeping it
      for personal non-commercial use) the files are gone: the weight and its
      three companion files from the Hetzner library, and those four plus their
      four hash sidecars from the cache volume, each listing empty afterwards;
      the BiRefNet folder beside it is untouched (6 library objects, 12 on the
      cache). The manifest row, family and every matting option had already gone
      on 2026-09-13, and nothing but explanatory comments names it. C.12.20 was
      already closed; with the model gone its failure has nothing left to fix._

## A.03 Civitai checkpoints and LoRAs (all `source: civitai`, pinned by version id)

- [x] **A.03.01** Chroma set (18.65 GB): rows and pull for NiceGirls UltraReal
      Chroma (2487473 / 2375819), NSFW Realism v1.0 (2357084 / 2247730) and the
      UnGloryHail BF16 checkpoint (2898818 / **2776781**, not the fp8 primary).
      LoRAs by S3 PUT; the checkpoint in the loader run. `chroma-txt2img`'s
      `checkpoint` enum gains `ungloryhail`; the `loras[]` enum gains both LoRAs
      beside the four C.12.01 ones. One live still per LoRA and one on
      UnGloryHail. `distribution: service` (all four flags). _2026-09-14,
      catalog half done; stays open for the UnGloryHail pull (its first library
      pull timed out opening the source; the retry pod is running) and the three
      live stills. The checkpoint enum on the five Chroma workflows that load a
      checkpoint offers the BF16 UnGloryHail file (service, explicit), and
      chroma-txt2img and chroma-img2img offer the NiceGirls UltraReal (service,
      racy) and NSFW Realism (service, explicit) LoRAs, each option's flags read
      from the manifest licence string. The rows already sit in the pinned
      Chroma family. None of the three versions lists trained words. NiceGirls
      and NSFW Realism are in the library._ _**Done 2026-09-14.** Pull complete
      and one live still per addition on chroma-txt2img (evidence A.05.02):
      UnGloryHail BF16 (733d1ab0, 152.8 s including its 17.8 GB load, 0.0671
      USD), NiceGirls UltraReal (e76be00b, 0.0688 USD on a cold worker) and NSFW
      Realism (aedf71f0, 46.7 s, 0.0205 USD)._
- [ ] **A.03.02** Z-Image set (32.83 GB): CyberRealistic Z-Image Turbo v8.0
      (3284136 / **3168412**, the bf16 file, not the nvfp4 primary) and
      Z-Image-Turbo-BF16-AIO (2447693 / 2339157) as `checkpoints/` rows in the
      loader run; PhotoReal BetterNudes v3 (2474435 / 2365660), Realistic
      Snapshot ZIT v5 (2617751 / 2505151), [ZIT] Breast Slider (2510875 /
      2398788), [ZIT] Detail Slider (2515203 / 2403021), DetailDeamonZ v1.1
      (2672935 / 2559725, serves ZIT and ZIB) by S3 PUT. The AIO loads with
      `CheckpointLoaderSimple` (encoder and VAE inside); CyberRealistic with
      `UNETLoader` plus the shared encoder. Enums on A.02.02's workflows; one
      live still per LoRA and per checkpoint. `distribution: service`.
      _2026-09-14: the catalog half landed with A.02.02 (checkpoint and LoRA
      enums with flags). Library: the AIO checkpoint and all five LoRAs are in.
      The CyberRealistic bf16 download answers HTTP 403 to the account's Civitai
      key on every attempt; it needs the model page opened while logged in to
      that account (any gate or early-access condition is the user's to accept),
      after which one more pull fetches it. Stays open for that file and the
      live stills._ _2026-09-14 later: the user confirmed CyberRealistic Z-Image
      Turbo v8.0 is in Civitai early access, which is why its download answers
      403; it is left unpulled on purpose (user decision, same day) until early
      access ends. Its row stays in the manifest; until the file is in the
      library, a Z-Image job that selects that checkpoint cannot sync its family
      and is refused before any GPU time._ _2026-09-14, live stills: the Turbo
      AIO checkpoint (57bcfbd0, 99.3 s with its 20.5 GB load, 0.0436 USD) and
      all five LoRAs on it (6.6 to 9.3 s, 0.0029 to 0.0041 USD each; same seed
      and prompt, five different hashes). Stays open only for CyberRealistic,
      which is in early access._ _2026-09-15: still early access. The version
      API for 3284136 now carries `paidAccess.endsAt` 2026-09-18T21:57:56Z, and
      a ranged download of file 3168412 answers 403 "Early Access" with the same
      deadline, so the pull and the still can run after that time (the row's
      SHA-256 matches the API's)._
- [x] **A.03.03** Wan service-tier set (3.12 GB, ten files, S3 PUT): Camera
      Tilt-down Undershot V2 high/low, Camera Tilt-up Overhead v1.1 high/low,
      Hip sway Type1 high/low, Hip Bump Dance high/low, [Wan2.2] Breast slider
      v2 high/low. The catalog's `loras[]` for `wan22-i2v` and `wan22-t2v`
      learns the pair shape (one entry loads the high file on the high-noise
      expert and the low file on the low-noise expert; a missing half fails
      loud). Trigger phrases from the version API go into the entry (`弧降仰底`,
      `(过顶升摇)`, "She sways her hips…", "hip bump dance"). One live clip per
      LoRA. `distribution: service`. _2026-09-14, catalog half done; stays open
      for the missing low halves and the live clips. One lora entry is a
      high/low pair: a declared pair map puts the high file on the high-noise
      expert's model chain and the low file on the low-noise one (after the
      lightx2v LoRA in speed mode), with one strength for both; a pair with
      either half missing fails at render with a named error, tested down to
      submission. Offered by base per the version API: the camera, hip sway and
      hip bump pairs are I2V so only wan22-i2v offers them, the breast slider is
      T2V so only wan22-t2v does. Trigger phrases are shown with the version id
      they came from, not appended to prompts. Library: every high half is in;
      the tilt-down, hip sway and hip bump low halves timed out and are in the
      retry pull._ _**Done 2026-09-14.** The retry pull landed every low half,
      and all five pairs rendered a live clip at 33 frames of 480 by 832
      (evidence A.05.02): hip bump (b8cb0057), camera tilt-down (133e1aa8),
      camera tilt-up (844ca07e), hip sway (39d9651b) on wan22-i2v, and the
      breast slider (a3d632ed) on wan22-t2v after a first attempt that lost
      ComfyUI (04d4b818, recorded). The camera pairs end on the angles they are
      named for; a same-seed render without tilt-down (89468c63) differs from
      its clip by 14.1 dB PSNR and ends on a looser angle, so the pair is
      applied. The hip sway and breast slider clips show no content change a
      viewer could name. Both catalogs' LoRA descriptions no longer say the
      clips are owed._
- [x] **A.03.04** Wan internal-only set (2.45 GB, eight files, S3 PUT): NSFW
      Posing Nude v2 HN/LN, Bouncing Boobs Wan 2.2 high/low (pin the Wan version
      — the model's newest is MiniMax H3), Twerking I2V high/low, Slow Twerk
      high/low. `distribution: internal_only` (A.04.02): never in a
      tenant-facing enum, accepted only from the operator tenant. One live clip
      per LoRA, rendered as operator. _2026-09-14, catalog half done; stays open
      for the posing pair's pull and the live clips. The four pairs are on
      wan22-i2v (all I2V) as internal only, explicit content: a tenant or
      anonymous caller never sees their ids or trigger phrases in the catalog,
      and a tenant selecting one is refused with 403 (route spec); the operator
      sees all eight pairs. Bouncing, twerking and slow twerk are in the
      library; both posing halves timed out and are in the retry pull._
      _2026-09-14, live clips: the retry pull landed both posing halves and all
      four pairs rendered one clip each on wan22-i2v (1b4c9f80, 9c76252d,
      ae5f9ca6, fdae4237; outputs kept out of git, recorded by hash in evidence
      A.05.02). A same-seed render without the posing pair (7cca256d) differs by
      22.9 dB PSNR, so the pair is applied, but every clip stays clothed from a
      clothed start image, including the three prompted with their trained
      phrases. The clips ran through the catalog harness with the operator's
      RunPod key, not as a job submitted by the operator tenant through the API,
      which is the path this item names. Stays open for one operator-tenant
      submission through the API._ _**Done 2026-09-14.** On the user's go, the
      operator tenant submitted `wan22-i2v` with the internal-only posing pair
      through `POST     /api/v1/jobs` on the local API (job 5aeb8e81, RunPod
      f1cfda18, 347.4 s, 0.4837 USD on the video ledger): the model cache leased
      and released wan22-i2v and wan-shared, provenance and the watermark were
      written, and the clip is recorded by hash (evidence A.05.02). A first
      submission without a consent id was refused before any GPU time, as the
      provenance ledger requires._ _2026-09-14, reopened on diagnosis (evidence
      A.05.02, A.03.04 diagnosis, 2.2509 USD approved by the user): the posing
      pair loads fully (no unmatched LoRA keys in the worker log), the full
      20-step schedule and 81 frames still keep a clothed start clothed, and
      from an artistic-nude start still the clip with the pair poses no
      differently from the same seed without it (23.0 dB apart, similar motion).
      The pipeline, operator gating, provenance and cache path are proven; no
      clip shows what a pair adds. Stays open until one clip does, or the owner
      decides to keep or drop the four explicit pairs as they are._ _**Done
      2026-09-15 on the owner's decision.** Asked in this session with the
      diagnosis above as the premise, the owner chose "Keep as-is, close
      A.03.04": the four explicit pairs stay in the manifest, library and
      `wan22-i2v` enums as internal only, with no claimed visual effect beyond
      the measured same-seed differences. E.01.06's body-LoRA A/B remains the
      place where each pair's effect is scored._
- [ ] **A.03.05** Instagirl WAN 2.2 (1822984): listed, **not pulled** — every
      version is a Diffusers `.zip`, which the lint rejects and the Comfy LoRA
      loader cannot read. Converting it would create a weight with no upstream
      hash to verify against; do that only on the user's explicit ask, as a new
      row with the conversion recorded as its provenance. Keep `[ ]` unless
      converted. _2026-09-18, board tag: the conversion happens only on the
      user's explicit ask, by this item's own wording._ `blocked:human`
- [x] **A.03.06** Photonic Fusion's manifest `license` string and the C.02-era
      rows: replace "verify commercial terms before public use" with the
      verified flags (`Image+RentCivit`, model 2485805; `internal_only`) and
      likewise write UnCanny's (`Image+RentCivit+Rent+Sell`, model 2086389;
      `service`); the inventory page shows the flag set per row. _**Done
      2026-09-13.** Both licence strings carry the verified flags (Photonic
      Fusion internal-only, UnCanny service, each with its Civitai model id),
      and so does every other Civitai row. The inventory API parses each row's
      licence string once into a flag block (Civitai flag set, distribution,
      content; null when the string does not state one, never a guessed
      service), and the RunPod page's artifact table has a Licence column: the
      flag set with distribution and content for a Civitai row, the licence name
      for an open one, and the full string on hover. A spec checks every Civitai
      row of the real manifest parses all three flags and obeys the rent rule.
      Tests: inventory specs 20, RunPod page spec 32, chromium
      `runpod-volume-licences.spec.ts` 1/1._

## A.04 Content policy, distribution flags and the licence register

- [x] **A.04.01** `content_policy` on every catalog workflow: `adult_ok`
      (chroma/\*, zimage/\*, wan22-\*, wan22-animate-2, scail2-animate,
      seedvr2-\*, sam3-\*, matting) or `sfw_only` (ltx25-av and its modes,
      hidream-o1-\*, klein4b-\*, qwen-\*), derived from the 2026-09-13 licence
      facts and stated in each entry's `policy_note`. Presets and LoRAs carry
      `content: racy | explicit | neutral`; the submit path refuses a `racy` or
      `explicit` preset, or any A.03 nude/body LoRA, on an `sfw_only` workflow
      with a 4xx naming the policy (fail closed, tested). Dashboard badge next
      to the proof-level badge. _**Done 2026-09-13.** Every one of the 17 RunPod
      catalog workflows declares a content policy and a policy note (the LTX-2.3
      graph is SFW only under the LTX licence's acceptable-use policy; the other
      16 allow adult content). Presets carry a content rating and send it with
      the job. The submit path refuses a racy or explicit preset or option on an
      SFW-only workflow with HTTP 422 before any cache lease, job row or
      billing, and refuses a catalog workflow with no readable policy the same
      way (fail closed). The dashboard shows the policy badge beside the proof
      badge. Tests: workflows library 740 passed; API policy service, route and
      projection specs 35 passed; chromium `catalog-content-policy.spec.ts` 2/2.
      The review also fixed two neighbouring chromium specs that had been
      failing on stale fixtures (the Jobs caption reads per-file facts, and a
      malformed response blanked the RunPod page: the client now refuses a cache
      snapshot or volume inventory without its shape), the motion presets' stale
      costs and inputs, and the OpenAPI 4xx contract (every refusal, including
      L.04's two 409s, now composes the shared error response)._
- [x] **A.04.02** `distribution: service | internal_only` on LoRA and checkpoint
      enum entries, from the Civitai flag rule (Image and Rent → service; Image
      without Rent → `internal_only`). The tenant-facing catalog (the surface
      Lilith reads) filters `internal_only` out; a job naming an `internal_only`
      entry is accepted only from the operator tenant (`tenant_isis_dev` class)
      and refused otherwise with a 403 naming the flag (tested both ways).
      _**Done 2026-09-13.** Checkpoint and LoRA options carry distribution and
      content in each workflow's option policy. Operator status comes only from
      verified credentials (`ISIS_OPERATOR_TENANT_IDS`, default the dev tenant),
      never from the request body. A non-operator never sees an internal-only
      option in the catalog listing, and a job selecting one is refused with
      HTTP 403 naming the flag; the same job from the operator tenant is
      accepted. Retries are judged as the caller retrying, and chains are
      checked step by step at submit. Tested both ways against a real job
      service in `content-policy.route.spec.ts`._
- [x] **A.04.03** Apply A.04.02 to what is already on the volume: Photonic
      Fusion → `internal_only`; Chroma1-HD, UnCanny, the four C.12.01 LoRAs (all
      four flags each, verified 2026-09-13) → `service`. _**Done 2026-09-13.**
      Photonic Fusion is internal-only (Civitai flags Image and RentCivit, read
      from the model API on 2026-09-13); Chroma1-HD, UnCanny and the four
      C.12.01 LoRAs are service with neutral content. No enum defaults to an
      internal-only option (a declaration check refuses that). The manifest
      licence strings carry the same flags (A.03.06)._
- [x] **A.04.04** Licence register
      `docs/domains/isis/runbooks/model-licences.md`: one row per manifest
      artifact (licence, territory, acceptable-use clause, Civitai flags,
      `content_policy`, `distribution`, verified-on date, source URL) and an
      **exclusions** table naming what must not be added and why (MiniMax H3,
      every Tencent Hunyuan model, Krea 2 / Kroma, Anima, Sulphur-2, Ideogram 4
      open weights, the ponpoke encoder, and any RentCivit-only Civitai entry).
      Linked from the runbook and the inventory page. A future model addition
      edits this file in the same commit as its manifest row. _**Done
      2026-09-13.** The register is generated from the manifest by
      `scripts/isis/model-licence-register.mjs`: 112 rows with every listed
      column and no unverified cell, the exclusions table, and a test that fails
      when the checked-in file differs from what the manifest generates, so a
      manifest row added without regenerating the register fails its test. The
      runbook links it, and the RunPod page's inventory card now links it too,
      with the count of internal-only artifacts beside the link._

## A.05 Build, live proof and closure

- [x] **A.05.01** One worker-image build after the new goldens exist: the
      build-time validator (V.01.09) validates every golden against the shadow
      volume of manifest rows, so the A.00.04 rows plus the A.01–A.03 goldens
      make one push to `runpod-comfyui-slim` prove all of them accepted (18 → N)
      and refresh the object-info snapshot with the SAM 3.1, SeedVR2, LTX-2.5,
      Animate-2, Z-Image, HiDream-O1, klein, Qwen-Image, SCAIL-2 and Depth
      Anything 3 class names. No base-image bump (everything is native by
      0.34.0). Record the build id and the accepted count. _**Done 2026-09-14.**
      Build `b5376e6b` from commit `d4f589596` (branch fast-forwarded at
      03:00:59Z, completed 03:21:17Z): the smoke test found all 141 required
      classes among 1149, and ComfyUI's own validator accepted 64 of 64 rendered
      goldens (18 before the arsenal), every new Z-Image, klein, HiDream-O1,
      Qwen-Image, LTX-2.5, Animate-2, SCAIL-2, SeedVR2, SAM 3.1 and Depth
      Anything 3 graph among them. The build released to both endpoints. The
      object-info snapshot was recaptured from that build's log (sha256 checked
      chunk by chunk); its loader combos now list the new rows, so the snapshot
      spec's exception list for model files the snapshot predated is empty
      again, and the Depth Anything 3 loader lists its file for the first time,
      which is the path-config fix working. No base-image bump._
- [ ] **A.05.02** Live proof matrix per A.00.05 (one render per model and per
      LoRA; warm-chain the video ones through `motion-live-proof.mjs`, stills
      through `runpod-catalog-run.mjs`), with the user's go on the spend first.
      Every entry ends `proof_level: rendered` with a measured rate, or stays
      `validated` with a `proof_note` naming the failure and the worker log path
      — never a rate that was not measured. _2026-09-14, partial: 28 renders
      against the approved 3 to 5 USD (3.6556 USD of execution plus 0.1136 USD
      of syncs at ledger rates; the balance fell 2.5526 USD including storage),
      all recorded under A.05.02 in the evidence file: every still-image model
      and LoRA in scope except CyberRealistic (early access), and one clip each
      for SAM 3.1 video, a Wan LoRA pair, Qwen-Image text to image, SeedVR2 7B,
      LTX-2.5, Animate-2 and SCAIL-2; 16 workflows are rendered with measured
      rates. Not yet rendered: qwen-edit and qwen-edit-control, LTX-2.5
      Ingredients and the pixel x2 tail, the Animate-2 896-class clip, a SCAIL-2
      multi-character clip, and eight Wan LoRA pairs; they wait on a further
      spend decision._ _2026-09-14, the approved remainder (6.2089 USD at ledger
      rates against the approved 6.5 to 8): every item that list named has
      rendered and is recorded under A.05.02 in the evidence file: qwen-edit and
      qwen-edit-control (union and inpaint), LTX-2.5 Ingredients and pixel x2
      plus a t2v clip with audible audio, the Animate-2 896-class clip, SCAIL-2
      with two characters, and all eight remaining Wan LoRA pairs, plus two
      same-seed baselines showing the pairs apply. 18 A-section workflows are
      now rendered with measured rates. Stays open for CyberRealistic (early
      access) and a default-schedule LTX-2.5 clip at the default shape
      (A.01.02), which no approval covers._
- [x] **A.05.03** Retirements executed (A.01.04, A.01.06, A.01.08, A.01.09,
      A.02.07, A.02.08), the manifest at its steady state (about 680 GB, 33.6 %
      headroom), lint green, evidence `## A.05` with the before/after inventory,
      the State block and counts of this tracker updated, memory note written.
      Then this section closes. _2026-09-13 later: "the manifest at its steady
      state" now means the library (about 680 GB on Hetzner) with the 400 GB
      cache holding the pinned core plus recent families._ _**Done 2026-09-14.**
      Every retirement named here is executed: each file is out of the catalog,
      the manifest, the register, the Hetzner library and the cache (RMBG-2.0 in
      the morning, the other thirteen rows at 20:40 to 20:44Z on the user's go).
      The library is at its steady state, 100 objects and 687.82 GB; the
      manifest 98 rows, 700.39 GB, 9 pinned families and a 239.03 GB pinned
      closure; strict lint is green with the cache invariant holding at 331.22
      of 380 GB. Evidence `## A.05.03` has the deleted keys and the before and
      after inventory, the State block at the top of this file has current
      counts, and the memory note is written. The A section itself stays open on
      the items the State block lists._

## L.00 Model library and cache: phase control and measurement (option B, added 2026-09-13)

- [x] **L.00.01** Transfer probe before any migration step quotes a wait time: a
      CPU pod in EU-RO-1 with `ax0oj250j3` mounted uploads
      `diffusion_models/Chroma1-HD.safetensors` (17.80 GB) to
      `isis/models/_probe/` on Hetzner single-stream and again with 8 parallel
      parts, downloads it back to pod scratch, and hashes both ways against the
      manifest sha256. Record MB/s each direction and whether Hetzner accepts a
      full-object `x-amz-checksum-sha256` on multipart completion (which decides
      whether L.01.05 needs download-side hashing for every row). Delete the
      probe object. About $0.02 of pod time and 18 GB of egress inside the
      allowance; ask before spending, as every live step here does. _**Done
      2026-09-13 13:48–14:42Z, pod `b1k0jr7fdbvror`, 3 237 s wall ≈ $0.054,
      deleted.** `library-probe` on `Chroma1-HD.safetensors` (17 800 038 288 B,
      266 × 64 MiB parts): up single-stream 709 s / 23.9 MB/s, up 8 parts 449 s
      / 37.8 MB/s, down single-stream 1 259 s / 13.5 MB/s, down 8 parts 816.5 s
      / 20.8 MB/s; both downloads hashed to the manifest sha256. **Hetzner does
      NOT validate a full-object checksum on multipart completion**: a two-part
      upload completed with a deliberately wrong `x-amz-checksum-sha256`
      (`FULL_OBJECT`) was accepted, as was the right one — so L.01.05 keeps
      download-side hashing for every row. `probeObjectsLeft: []`. Result file
      `.oshun/library-probe-result.json` on `ax0oj250j3`._
- [x] **L.00.02** Rewrite the wait-time estimates in this file from L.00.01's
      measured download rate (the decision block's figures and L.04.03's 409
      body both use it). Until then those figures are labelled estimates from
      the Hugging Face transfer rate. _**Done 2026-09-13.** The facts block now
      carries the measured rates and the derived waits (core ≈ 2.8 h, LTX-2.3 ≈
      64 min, Animate ≈ 29 min, VACE ≈ 28 min) in place of the Hugging Face
      figure; A.00.03's pull estimate carries a dated supersession note; the 409
      body and the dry-run plan compute their wait from
      `ISIS_RUNPOD_CACHE_SYNC_MB_PER_SECOND`, which the runbook recipe sets to
      20.8 (unset, they return `null` with a reason, never a guess)._
- [x] **L.00.03** Evidence file gains `## L.00`–`## L.07`; every pod run records
      wall clock, pod id, cost and the loader's result file, exactly as V.02.04
      did. _**Done 2026-09-13.** All eight sections exist, and the L.04 table
      holds all thirteen pods the section ran, from the 13:48Z library probe to
      the LTX-2.3 resume sync, each with its window, wall clock, cost (billed
      rate for loader pods, the API's booked line where it drove the pod) and
      result file. The seven result files that survived are committed under the
      evidence folder; the rows without one say why (hung, stalled, overwritten
      by the next sync, or failed by takeover). The last row closed at 22:55Z:
      the LTX-2.3 sync landed three of seven files, froze on the Gemma encoder
      while the arsenal library pull loaded the same bucket, and was failed by
      takeover with its pod deleted (0.123 USD). The arsenal pull's own pod is
      recorded under A.00.03._

## L.01 The library on Hetzner (source of truth for weights)

- [x] **L.01.01** Manifest `library` block:
      `{provider: "hetzner-object-storage", endpoint: "https://hel1.your-objectstorage.com", region: "hel1", bucket: "app-dev-server", prefix: "isis/models/", auth: ["HETZNER_APP_DEV_S3_ACCESS_KEY", "HETZNER_APP_DEV_S3_SECRET_KEY"]}`.
      A row's library key is `prefix + destPath`, so the library key and the
      cache path are the same string. Lint: the block's shape, no key outside
      the prefix, and a **warning** when the library total passes 1000 GB (the
      allowance is account-wide and shared with outputs). Spec cases for each.
      _**Done 2026-09-13 (`28083a4c432`).** `library` =
      `{provider: hetzner-object-storage, endpoint: https://hel1.your-objectstorage.com, region: hel1, bucket: app-dev-server, prefix: isis/models/, auth: [HETZNER_APP_DEV_S3_ACCESS_KEY, HETZNER_APP_DEV_S3_SECRET_KEY]}`.
      Lint checks the provider, an https bare-origin endpoint, a valid bucket
      name, a relative prefix ending in `/`, exactly two env NAMES and no
      credential value, that no row's key escapes the prefix, and warns (not
      errors) past 1000 GB. `runpod-volume-manifest-lint.test.mjs` case
      `library block: shape, key prefix, credential names only, and the 1000 GB account warning`
      covers each, 10/10._
- [x] **L.01.02** Loader `library-seed` mode: reads each row from the mounted
      volume, uploads to Hetzner (single PUT up to 5 GB, multipart above),
      computes sha256 while reading and **aborts the multipart upload** on a
      mismatch with the row, stores `x-amz-meta-sha256`, skips an object whose
      HEAD size and metadata already match, and writes a result file.
      `runpod-provision.mjs pod create-loader --mode library-seed` injects the
      two Hetzner keys as env the way it injects `CIVITAI_API_KEY` (redacted in
      `--dry-run`, never in command text). Tests for the skip rule, the
      part-size choice and the abort path against a local S3 test double at the
      dependency boundary. _**Done 2026-09-13 (`1da465087a6`, `9b31b96481a`).**
      `LOADER_MODE=library-seed` in `runpod-volume-loader.py` on a stdlib SigV4
      client (checked against eight botocore vectors): single signed PUT up to
      512 MiB with the manifest sha256 as the payload hash (the server refuses
      wrong bytes), multipart above with per-part hashes, the whole-file sha256
      computed while reading and an ABORT on mismatch, `x-amz-meta-sha256`
      stored, HEAD size + metadata skip. `pod create-loader --mode library-seed`
      injects `LIBRARY_ACCESS_KEY`/`LIBRARY_SECRET_KEY` from the manifest's env
      names, redacted in `--dry-run` (asserted), never in command text. Tests
      against a real local S3 double: the skip rule (including size-only is NOT
      enough), the part-size choice, the multipart abort path, the
      server-refused single PUT. Live against Hetzner: four real files seeded,
      rerun skipped, 0 failures, test objects deleted._
- [x] **L.01.03** Seed run: all 50 current rows (367.17 GB) from `ax0oj250j3` to
      the library. Done when a listing of `isis/models/` shows 50 objects whose
      sizes match the manifest and the result file shows 0 failures. Record wall
      clock and pod cost. _**Done 2026-09-13 17:27:45Z.** Four launches, because
      the pod path hung three times: two pods on S3 connections Hetzner stopped
      answering (fixed by a 30 s stall timeout, `a94f2832105`) and one on a
      volume read that never returned, 40 minutes at 0 % CPU (fixed afterwards
      by a watchdog that exits 75 and a start loop that reruns, `111a49e7518`).
      The last pod, `wkd9odg71h3tls`, ran 2478 s and its result file reports 50
      rows ok and 0 failures, finished rows skipped by size and sha256. A
      listing of `isis/models/` shows 50 objects, 367.17 GB, every size matching
      the manifest and every `x-amz-meta-sha256` matching the row. Pod time
      across the four launches about 2.7 hours at 0.06 USD per hour, about 0.16
      USD; all four pods deleted and every abandoned multipart upload aborted._
- [x] **L.01.04** Loader `library-pull` mode: Hugging Face and Civitai rows
      streamed straight to Hetzner with sha256 computed in flight and no local
      copy beyond one part buffer; the same abort rule. Every A-section pull
      uses it (A.00.03 note). _**Done 2026-09-13.** `LOADER_MODE=library-pull`
      streams a Hugging Face or Civitai row straight into `upload_object` — no
      local file, at most `LIBRARY_PARALLEL` part buffers in memory — refusing
      first when the source's Content-Length disagrees with the manifest, and
      with the same abort rule. Three `LibraryPull` cases against a local
      stand-in source server: multipart and single-PUT rows land with their sha
      and a rerun skips; source bytes that disagree with the manifest abort and
      leave no object and no open upload; a lying Content-Length is refused
      before any PUT. Loader suite 17/17. `--mode library-pull` injects the
      Civitai key only when the manifest has Civitai rows and may run without a
      volume. Every A-section pull uses it (runbook §5c)._
- [x] **L.01.05** Download-side verification of **every** library row before
      `ax0oj250j3` is deleted: a row counts as verified when a cache sync
      (L.04.01) or a `library-verify` pass has hashed the bytes it downloaded
      and matched the manifest. The core rows are verified by L.06.02's first
      sync; the 154.91 GB of non-core rows get the verify pass. Per-row
      `verifiedAt` in the result file. If L.00.01 shows Hetzner validates a
      full-object sha256 checksum at upload, record that and scope this item
      down in a dated note rather than skipping it silently.

## L.02 Families and the pinned core

      _**Done 2026-09-13 19:33Z; every library object hashed after download.**
      The 34 core rows by the two L.06.02 syncs (loader cache-sync verifies each
      file against the manifest before renaming it into place). The 16 non-core
      rows: 14 by the verify pod `ktbpl2bdda9vgf` (18:08:27Z, 95.85 GB),
      `gemma3-12b-it-bf16` by the retry pod `9t25i5c9aoe0j6` (18:27:50Z), and
      `wan21-vace-14b-fp16` by the VACE cache sync `eb61d6df` (19:33:33Z, 34.68
      GB at 24.9 MiB/s), whose three controlnet_aux files matched as well. The
      six companions: BiRefNet's three by the core follow-up sync, RMBG-2.0's
      three by a library-verify run from the Mac. L.00.01 showed Hetzner does
      not validate full-object checksums, so the item kept its full scope.
      Per-file `verifiedAt` and hashes are in the result files under
      `docs/agents/evidence/isis-chroma-runpod/l-results/`. The old volume was
      deleted at 18:13Z, before the last three of these landed (L.06.05)._

- [x] **L.02.01** `families` in the manifest: each artifact lists every family
      that needs it (a shared file lists several); each family record is
      `{id, pinned, tier: image | video | both}`. Initial pinned core, 212.26
      GB: `chroma-core` (with the C.12.01 LoRAs), `wan22-i2v`, `wan22-t2v`,
      `wan-shared`, `sam3`, `birefnet`, `flashvsr`, `gimm-vfi`, `realesrgan`.
      Every A-row gets its family at A.00.04; Civitai LoRAs join their base's
      family (the Wan internal-only pairs join `wan22-i2v` and inherit its pin —
      2.45 GB, not worth a separate family). _**Done 2026-09-13
      (`28083a4c432`).** 15 families, 9 pinned (`chroma-core` with the four
      C.12.01 LoRAs, `wan22-i2v`, `wan22-t2v`, `wan-shared`, `sam3`, `birefnet`,
      `flashvsr`, `gimm-vfi`, `realesrgan`) = 212.26 GB exactly; shared files
      (umt5, the Wan VAE, clip_vision_h) list every family that needs them. The
      A-section rows get their family at A.00.04 (not yet written)._
- [x] **L.02.02** `requires_families` on every catalog workflow, checked rather
      than trusted: the static validator (V.06.06) fails when a model filename a
      rendered graph references is not covered by the union of the declared
      families' files, including every `_condition` branch and enum value.
      _**Done 2026-09-13 (`02be697dd61`).** `requires_families` on all 17 chroma
      and motion workflows; the static validator's `MODEL_NOT_IN_FAMILIES` fails
      when any model a rendered graph references is outside the declared
      families, matching basenames, extensionless names and pack folders plus a
      class table for the SAM 3 loaders. `model-families.spec.ts` sweeps
      defaults, every enum value and both booleans: no uncovered file, no
      declared family nothing loads, an under-declaration caught only in the
      branch that needs it (ltx23-av depth and pose)._
- [x] **L.02.03** Cache-size invariants in the lint, replacing the 20 % headroom
      rule for the cache (the library keeps its own warning): pinned closure
      plus the largest unpinned family closure must be at most 95 % of the cache
      size (today 212.26 + 106.32 = 318.58 of 380 GB), and every single family's
      closure must fit beside the pinned core, otherwise that family can never
      load. Spec cases at 400 GB and at a size that fails. _**Done 2026-09-13
      (`28083a4c432`).** The lint replaces the volume headroom rule when `cache`
      is present: pinned closure + largest unpinned family ≤ `invariantRatio`
      (0.95) × cache (today 212.26 + 80.37 = 292.64 of 380 GB — ltx23 is the
      largest, not Qwen-Image, which is not in the manifest yet), and every
      family fits beside the core. Spec cases at 400 GB (passes), 300 GB
      (invariant fails, ltx23 still loads) and 250 GB (ltx23 can never load)._

## L.03 Cache state, leases and least-recently-used eviction (generation-api)

- [x] **L.03.01** Migration: `runpod_cache_families` (volume id, family id,
      state `absent | syncing | cached | evicting`, bytes, `last_used_at`,
      `synced_at`) and `runpod_cache_leases` (family id, job id, acquired at),
      plus an append-only `runpod_cache_events` (hit, miss, sync started, sync
      done, sync failed, evicted; family, job id, bytes, at). _**Done 2026-09-13
      (`9b31b96481a`).** `runpod_cache_families`, `runpod_cache_leases` (foreign
      key to the family row) and append-only `runpod_cache_events` (a trigger
      blocks UPDATE/DELETE/TRUNCATE), created with `CREATE TABLE IF NOT EXISTS`
      like `jobs`; L.04.02 added `runpod_cache_syncs` with a partial unique
      index allowing one running sync per volume._
- [x] **L.03.02** Pure planner `planCacheSync` over families, file membership,
      cached state, pins, leases and last-used times: returns
      `{pulls, evictions}` or a typed refusal (`exceeds_cache`,
      `blocked_by_leases`). Freed bytes are reference-counted (a file is freed
      only when no remaining cached or pinned family references it); nothing is
      evicted when the missing bytes plus a 5 % margin already fit; otherwise
      unpinned, unleased families are evicted in ascending `last_used_at` (a
      family synced but never used counts from its `synced_at`) until the
      request fits, and no further. One spec file covering: a request already
      cached is a hit with an empty plan; no eviction when it fits; eviction
      order; a shared file not counted as freed while referenced; pinned and
      leased families never chosen; the refusal when even full eviction cannot
      fit. _**Done 2026-09-13.** `planCacheSync` in
      `runpod-model-cache/planner.ts` (pure, read in full): hit, plan or typed
      refusal (`exceeds_cache`, `blocked_by_leases`, plus
      `blocked_by_volume_state` and `unknown_family`); reference-counted freed
      bytes; nothing evicted when it fits with the 5 % margin;
      least-recently-used unpinned, unleased families evicted only until it
      fits; residue from failed syncs evicted first. 17 planner specs including
      every case the item names and the real manifest (pinned 212.26 GB; ltx23
      on the core at 400 GB is a plan with zero evictions)._
- [x] **L.03.03** Leases: acquired at submit for the job's `requires_families`
      in the same transaction as the cached check; released when the job reaches
      a terminal state; a reconciler releases a lease whose job is terminal or
      older than the execution timeout plus the queue deadline. Tests for the
      race (submit while a sync plans an eviction of the same family). _**Done
      2026-09-13.** `acquireLeases` checks `cached` and inserts in one
      transaction; `releaseLeases`; `reapStaleLeases` with injected job lookups;
      `beginEvictions` marks `evicting` all-or-none and refuses a leased or
      syncing family. The race is tested against real Postgres in both forced
      orders and in 25 concurrent rounds with exactly one winner each._
- [x] **L.03.04** Reconciler before every plan: list the cache volume through
      its S3 API; a family is `cached` only when every file is present at the
      manifest size. A `cached` family with a missing or short file flips to
      `absent` with a logged event — the table alone is never trusted. _**Done
      2026-09-13.** `reconcileCacheState` takes an injected `listVolume`; a
      family is `cached` only when every file is present at manifest size, a
      recorded `cached` family with a missing or short file flips to `absent`
      with an event, and unmanaged bytes are measured and counted as used._
- [x] **L.03.05** `last_used_at` is written when a job **completes**, from the
      job ledger; a failed job does not refresh it (a family that only fails
      should age out). Hit and miss events are written at submit. _**Done
      2026-09-13.** `recordFamilyUse` on COMPLETED only (`last_used_at` never
      moves backwards), `recordHitOrMiss` at submit; wired in `JobService` by
      L.04.03 (completion, failure and cancellation release leases; only
      completion refreshes last use)._

## L.04 Sync executor

- [x] **L.04.01** Loader `cache-sync` mode: input is a plan; evictions run first
      (filesystem delete inside the pod, then a listing proves the bytes are
      gone), then each pull downloads from Hetzner to `<dest>.partial`, verifies
      sha256, and renames atomically. A failed file leaves its family `absent`,
      never `cached`; the result file names every row. Idempotent. _**Done
      2026-09-13 (`1da465087a6`).** `LOADER_MODE=cache-sync`: evictions first
      (delete file, marker and partial, then the directory listing is the
      proof), each pull downloaded with parallel ranged GETs to
      `<dest>.partial`, hashed in flight, verified, renamed atomically with a
      `<dest>.sha256` marker; a failed file leaves the family `absent`;
      idempotent (a present file at size with a matching marker is skipped).
      Specs: evict-then-pull with marker and idempotent rerun, a bad file
      leaving no destination and the family absent, a path outside `models/`
      refused. Live: four files pulled from Hetzner, 0 failures._
- [x] **L.04.02** `POST /api/v1/runpod/cache/sync` with `{workflows[]}` or
      `{families[]}`: reconcile, plan, create the pod, poll the result, update
      state, delete the pod. One sync per volume at a time (lock);
      `dryRun: true` returns the plan with bytes, evictions and the estimated
      wait. The pod's time bills a `cache_sync` line in the daily ledger at the
      CPU pod rate, and the fail-closed budget guardrail and the kill switch
      apply to it. _**Done 2026-09-13 (`0fe7d06ba70`), reviewed.**
      `POST /api/v1/runpod/cache/sync` and `GET /api/v1/runpod/cache` in
      `routes/runpod-cache.ts`; orchestration in `sync.service.ts`: reconcile,
      plan, dry-run with `estimatedWaitSeconds` from the measured rate (or
      `null` with a reason), one sync per volume (partial unique index,
      heartbeat takeover, boot recovery), refusal when the kill switch is
      engaged (read live from both endpoints; unreadable → 503) or the guardrail
      blocks, pod created from `buildLoaderPodBody`, result polled, applied,
      **pod deleted whatever happens** (retried; a surviving pod logs
      `…STILL BILLING…`), a `cache_sync` line booked at the pod's `costPerHr`
      for its wall clock (on the image ledger). 503 `cache_not_configured`
      without a cache volume id. OpenAPI: two operations, eight schemas. Specs:
      sync service 11, routes 6._
- [x] **L.04.03** Submit path: a job whose families are not all `cached` is
      refused with `409 models_not_cached`, naming the families, their bytes,
      the estimated wait and the sync call. With
      `ISIS_RUNPOD_CACHE_AUTOSYNC=true` the job is instead held as
      `awaiting_cache` and the sync is started for it. Default false. Tests for
      both modes and for the lease being held across the wait. _**Done
      2026-09-13 (`0fe7d06ba70`), reviewed.** Inside `JobService.submit` (so
      batch, chain and retry are covered): worker-comfyui catalog jobs resolve
      `requires_families`, write hit/miss events and lease in the cached-check
      transaction. Not cached → `409 models_not_cached` from `POST /jobs` with
      families, bytes, wait and the sync call, before the job exists; with
      `ISIS_RUNPOD_CACHE_AUTOSYNC=true` the job is stored `awaiting_cache` with
      no outbox entry, a sync is started or joined, and it is released into the
      queue (row-locked) or failed when its families settle. Leases released on
      every terminal state. Unconfigured cache = submit unchanged (tested); the
      provider check runs before any manifest read. Client, dashboard and status
      label know `awaiting_cache`. 8 submit-gating specs; 97/97 in the combined
      set; `tsc -p tsconfig.app.json` 10 errors before and after, all
      pre-existing._

## L.05 Dashboard

- [x] **L.05.01** Cache panel on the RunPod page: volume used and free, families
      with state, bytes, pinned badge, last used and lease count, and the recent
      events. A "Warm for session" picker takes workflows, shows the dry-run
      plan (pulls, evictions, bytes, estimated wait) and runs the sync behind
      the same arm/confirm pattern as the kill switch. Verified in real chromium
      through the Playwright harness. _**Done 2026-09-13.**
      `RunPodCachePanel.tsx` on the RunPod page, view logic in
      `runpod-cache-panel-utils.ts` (7 tests), client methods `getRunPodCache`,
      `planRunPodCacheSync` and `startRunPodCacheSync` (never retried: a retried
      start could launch a second billed pod), and `client-projection.spec.ts`
      holding the API, client and OpenAPI shapes to the same fields (11 tests).
      A 503 `cache_not_configured` renders one sentence, not a card of zeros.
      Chromium `e2e/runpod-model-cache-panel.spec.ts` 2/2 with the API mocked at
      the network boundary: the volume line and bar, pinned-first family rows
      with lease counts, events, a dry run that sends exactly
      `{workflows:['ltx23-av'], dryRun:true}`, a stale-plan notice when the
      selection changes, cancel sending nothing, and confirm sending exactly one
      start. The first read against a real cache volume follows L.06.02._

## L.06 Migration of the volumes

- [x] **L.06.01** Create `isis-model-cache`, 400 GB, EU-RO-1, with
      `runpod-provision.mjs volume create --name isis-model-cache --size 400 --dc EU-RO-1 --yes`
      after a `--dry-run`. The user's 2026-09-13 decision is the go for the
      size; A.00.02 (balance) must be checked first. Desired-state gains the
      entry with `monthlyUsd` 28.00; the manifest gains `cache.volumeId`.
      _**Done 2026-09-13 15:26:33Z.** Balance checked first (A.00.02: $17.94).
      Dry run, then `volume create --yes` returned `5bst2pgw7y`
      (`isis-model-cache`, 400 GB, EU-RO-1).
      `infra/runpod/volumes/desired-state.json` gains the entry at $28.00/month
      with its size history; the manifest's `cache.volumeId` is `5bst2pgw7y` and
      the lint still reads 292.64 GB of 380 GB allowed. **Consequence until
      L.06.03:** an API booted from this commit treats the cache as configured
      and gates submits against a volume that is still empty and not yet mounted
      by the endpoints, so a dev session before L.06.02 gets
      `409 models_not_cached`; L.06.02 waits only on the library seed
      (L.01.03)._
- [x] **L.06.02** First sync of the pinned core (212.26 GB) from the library
      into the new volume through L.04 — which is also the download-side
      verification of the core rows for L.01.05. Record wall clock, measured
      rate and pod cost. _**Done 2026-09-13 19:01Z, in two syncs through the
      API.** Sync `6e9cc338` (pod `uzcxhv22fkl5na`, 17:37 to 18:37:53Z, wall
      3630.5 s, 0.063 USD booked) pulled 31 of 34 files: three Wan 2.2 I2V files
      died on ranged reads that stalled five times on one range, and the API's
      reconcile then failed on a 1000-key volume listing that passed
      Cloudflare's 100 s limit (HTTP 524). Both fixed in `707893f36fa` (50-key
      retried pages, 12 attempts per range). Sync `7620b385` (pod
      `1q4axik9vvhuv6`, wall 739 s, 0.015 USD) pulled exactly the missing six:
      the three Wan files at 70.7 to 76.9 MiB/s and the three BiRefNet
      companions that `ca15cfb8f0e` added to the manifest; 0 failures, state
      `succeeded`. The API then reads all nine pinned families `cached`, 212.26
      GB used, 187.74 GB free, 0 unmanaged bytes, which is the lint's pinned
      figure exactly. Measured rate: median 40.6 MiB/s per file while three
      transfers shared Hetzner, about 75 MiB/s alone (the recipe now says 40).
      Every core row was hashed by the loader on the way in, which is its
      download-side verification for L.01.05. Result files in
      `docs/agents/evidence/isis-chroma-runpod/l-results/`._

- [x] **L.06.03** Point both endpoints at the new volume. Try the console's
      endpoint edit first and re-save (never GraphQL `saveEndpoint`, which
      wedged `6l1f3tku7z2zoy`). If RunPod does not allow changing an endpoint's
      network volume, create replacement endpoints on the same git release and
      template, then update desired-state, the runbook and any throwaway env
      file in the same step (a deleted endpoint id still accepts `/run` and
      queues forever). The drift checker reads green afterwards. _**Done
      2026-09-13 18:12Z.** The console edit works; no replacement endpoints were
      needed. On each endpoint, Edit endpoint, then Advanced, then Network
      volumes: `isis-model-cache` ticked, `isis-chroma-models` unticked, saved.
      GraphQL `myself.endpoints` then read `networkVolumeId: 5bst2pgw7y` for
      both, and the drift checker reports no drift for `comfyui-chroma` and
      `comfyui-video` with `networkVolumeId = 5bst2pgw7y`. Endpoint
      desired-state, both inventories, the build config and manifest, the
      manifest's volume block, the endpoint config validator (now read from
      `cache.volumeId` instead of a pinned id) and the runbook moved in the same
      commit. The throwaway env file never set `RUNPOD_VOLUME_ID`._
- [x] **L.06.04** Proof on the new volume: the model-free probe; one
      `chroma-txt2img` still; one `wan22-i2v` clip; one full miss, sync and
      render cycle for an unpinned family (`wan21-vace`, 34.68 GB) with the
      measured wait; and one forced eviction on the real volume (sync families
      until one must go) showing the planner chose the longest-unused unpinned
      family and freed the bytes it said. Evidence `## L.06`. _**Done 2026-09-13
      20:51Z; details in evidence `## L.06`.** Model-free probe on the image
      endpoint (execution 8.9 s, output on Hetzner). Chroma still through the
      API: the first came back unwatermarked because the Hetzner output path
      dropped `requiresSigning` in three mappings, fixed in `6e3691ad7b9`; the
      re-render decodes its watermark with 512 of 512 copies intact. Wan 2.2 I2V
      clip, 33 frames 832x480, 0.45 USD. VACE cycle: HTTP 409
      `models_not_cached` naming `wan21-vace` and `controlnet-aux` with the sync
      body, sync 24.4 min, render 5.7 min after 21 min of GPU queue, 52 min miss
      to clip, 0.48 USD. Forced eviction: the whole library fits 380 GB, so the
      API ran on a proof-only manifest copy with `cache.sizeGb` 320; asked for
      `ltx23-av`, it evicted `wan21-vace` (last used 20:02:42Z) rather than
      `rmbg-2.0` (synced 20:04:09Z) or the `controlnet-aux` the request needs,
      and managed bytes fell by exactly the 34.68 GB planned. Found on the way:
      the jobs table's type constraint refuses `video-to-video` that the route
      accepts (HTTP 500), pre-existing and recorded, not fixed here._
- [x] **L.06.05** Delete `ax0oj250j3` (1024 GB) only when L.01.05 shows every
      library row download-verified and L.06.04 has rendered, and only on the
      user's explicit go at that moment: it is irreversible and it is the last
      copy on RunPod. Record the storage bill before and after ($71.20 to
      $28.00), remove its desired-state entry with a history note. _**Done
      2026-09-13 18:13:21Z, on the user's explicit go ahead of both gates** ("go
      ahead with deleting the old volume", given while the core sync was still
      running). What held at that moment: both endpoints repointed (L.06.03);
      nothing else mounted the volume; its four loader result files copied to
      `docs/agents/evidence/isis-chroma-runpod/l-results/`; all 50 library rows
      hash-checked against the manifest at upload with matching
      `x-amz-meta-sha256`; 14 of the 16 non-core rows download-verified (95.85
      GB). Not yet held: the pinned-core download verification (the running
      sync) and two non-core rows, `wan21-vace-14b-fp16` and
      `gemma3-12b-it-bf16`, whose verify hit Hetzner read timeouts. Both are
      ungated Hugging Face rows at pinned revisions, so the library can rebuild
      them; their re-verify was running on the cache volume. L.06.04 had not
      rendered. `volume delete ax0oj250j3 --yes` returned, and the account's
      volume list then held only `5bst2pgw7y`. Storage went from 71.20 plus
      28.00 USD a month to 28.00: `currentSpendPerHr` 0.222 with two CPU pods
      before, 0.162 with the same two pods after. Volumes desired-state moves
      the entry to `retiredVolumes` with this history._

## L.07 Operation

- [ ] **L.07.01** After four weeks of real use (conditional): hit, miss and
      eviction counts per family from `runpod_cache_events`. Promote a family
      missed in more than half of sessions into the pinned core, or grow the
      cache if the log shows same-day evictions of families that were needed
      again; re-run L.02.03's invariants for the new shape. Record the decision
      either way. _2026-09-18, board tag: conditional on four weeks of real use
      of the cache, which has not happened yet; the counts it needs do not
      exist._ `blocked:release`
- [x] **L.07.02** Outputs retention on Hetzner: `isis/outputs/` draws on the
      same account allowance as the library (about 680 GB steady), so a sweeper
      or bucket lifecycle rule keeps outputs bounded, and an alarm fires when
      account-wide usage passes 900 GB, before billing starts silently. _**Done
      2026-09-13.** A sweeper, not a lifecycle rule, so the refusal of
      `isis/models/` lives in code: `sweepHetznerOutputs` in
      `runpod-volume-s3-put.mjs` allows only `isis/outputs/`, refuses days < 1,
      skips unreadable dates, and is a dry run by default; `measureAccountUsage`
      sums every bucket `ListBuckets` returns with a per-prefix breakdown. Node
      tests 30/30 (4 new, against the fake S3 made bucket-aware). The API's
      `hetzner-storage-guard.service.ts` (off unless
      `ISIS_HETZNER_STORAGE_GUARD_ENABLED`, dry run until told otherwise) sweeps
      then measures every 6 h, measures without sweeping a minute after boot,
      logs `ops.hetzner_storage.usage_high` at error level on every
      over-the-line check, and posts the signed `storage.hetzner.usage_high`
      webhook once per UTC day (new event type, schema in the registry). Spec
      12/12. **Live 2026-09-13 15:20Z** through the guard's own runtime loader:
      dry-run sweep of the real bucket, usage 17.80 GB in 1 object (the seed's
      first row), not over; with the line set to 1 byte the same live reading
      raised once and held on the second check. **Found and fixed on the way:**
      the budget alarms (C.04.06) handed store records to the notifier, which
      posts to `url`; records call it `endpointUrl`, so every budget webhook
      would have logged a delivery error and delivered nothing.
      `alarmSubscriptionFromRecord` maps both paths, with a regression spec, and
      the API's pre-existing type errors drop from 10 to 9._
- [x] **L.07.03** Runbook
      `docs/domains/isis/runbooks/chroma-runpod-dev-stack.md` gains the library
      and cache section: where weights live, how to warm a session, what
      `409 models_not_cached` means, how to pin or unpin a family, and how to
      add a model (library row, family, pull, then the cache picks it up on
      first use). _**Done 2026-09-13.** Runbook §5c: where weights live, adding
      a model (row, family, `requires_families`, `library-pull`, the cache picks
      it up), the loader modes and their result files, warming a session,
      `409 models_not_cached` and autosync, pinning, and the verification gate
      before the old volume goes. Env names match the runtime:
      `ISIS_RUNPOD_CACHE_VOLUME_ID`, `ISIS_RUNPOD_CACHE_AUTOSYNC`,
      `ISIS_RUNPOD_CACHE_SYNC_MB_PER_SECOND` (20.8 in the recipe),
      `ISIS_RUNPOD_CACHE_SYNC_PARALLEL`, `ISIS_RUNPOD_CACHE_SYNC_POLL_MS`,
      `ISIS_RUNPOD_CACHE_SYNC_TIMEOUT_MS`._

## Open 3D studio architecture and review (added 2026-09-13)

### Scope and engineering decisions

Build a production 3D creation and scene workspace inside Isis, using its
existing dashboard, API, jobs, output registry, model governance and RunPod
infrastructure. Meshy and Higgsfield are capability/quality references, not
runtime dependencies. This extends the image/video work; it does not replace or
delay its remaining tasks. T.00–T.21 are a new backlog, not implementation
signoff. Owner: @GreyChimp; the owner assigns implementation work per phase.

The hybrid architecture is sound. The following corrections to the pasted
proposal are part of this plan:

1. **Three specialist lanes, one durable workspace.** Use neural generation for
   organic assets, procedural Blender/CadQuery/OpenSCAD for constructed objects,
   and reconstruction for photographs. A vehicle may mix lanes. Routing
   considers input evidence, editability, dimensions, rights, cost and intended
   use; object category alone is insufficient. A photo cannot establish exact
   hidden dimensions. Ask for measurements when necessary and label inferred
   surfaces rather than treating them as recovered truth.
2. **Open core, optional hosted intelligence.** TRELLIS.2 is the first primary
   generator candidate; TripoSG supplies geometry at a smaller memory tier;
   Step1X and original TRELLIS are alternatives with distinct versioned
   adapters. Use Blender and open CAD/mesh tools, with a replaceable director
   and visual critic. Astra may improve planning and QA, but is a proprietary
   hosted dependency. A fully self-hosted profile must pass with an admitted
   local text/tool model and local vision model, or explicitly disclose reduced
   autonomy; deterministic manual operation remains available. Do not call an
   API-dependent profile fully self-hosted.
3. **Preserve earlier restrictions.** No Houdini, mandatory Meshy/Higgsfield
   service, new account, quantized generation weights, or unapproved storage
   growth. Hunyuan3D and HY-Motion remain excluded under A.04.04 and the
   existing Tencent decision; document their capability mappings without
   deploying them. SAM 3D is a separately admitted custom-license option, not
   the same family or entitlement as SAM 3/3.1 segmentation. Unity and Unreal
   are optional delivery targets, not open-source production dependencies;
   provide Three.js and Godot delivery in the open profile.
4. **Admission covers the entire execution path.** MIT/Apache repository badges
   do not settle weight, encoder, rasterizer, body-model, motion-data, output or
   redistribution rights. Blender is an open-source copyleft tool, not a
   permissively licensed library; document the actual distribution boundary and
   obligations. MotionGPT3/MDM/DiP are candidates pending their dependency and
   checkpoint review, not pre-approved commercial motion stacks.
   Mixamo-compatible skeleton mapping does not authorize republishing a motion
   catalog. Prefer original or explicitly redistributable clips.
5. **Preserve good assets during repair.** A native PBR asset may bypass
   retexturing; a rigid prop bypasses rigging and motion; intentional open
   surfaces must not be automatically sealed. Local edits require actual part
   identity, correspondence and preservation checks. No promise that any
   generator supports masked 3D regeneration; use supported object replacement,
   procedural repair or manual edits when it does not.
6. **Measure parity rather than promising it.** Neither the pasted 85–95%
   coverage estimate nor the numerical SOTA ratings are accepted benchmarks.
   Rigging is not universally solved, and valid topology is not necessarily
   suitable for character deformation. CAD benchmark results do not establish
   organic mesh quality. Acceptance is by asset category and delivery profile,
   with explicit failed cases and artist review for difficult deformation.
7. **Bound autonomy in code.** Start with a director and separate critic
   executions; geometry, topology, material, rig, motion, engine and art roles
   are typed evaluations, not eight permanently running agents. Deterministic
   validators enforce hard gates. Critics cannot override them. Parallel jobs
   share one budget, resource leases and version checks. Scripts run in isolated
   workers, never with control-plane credentials or unrestricted host access.

### Primary-source review and candidate disposition

Reviewed 2026-09-13. These are upstream claims and selection inputs, **not Isis
measurements or blanket legal clearance**. T.01 must pin code/weights/licenses
and dependencies before admission; moving upstream pages are discovery links.

| Component             | Evidence and qualification                                                                                                                                                                                                                                                                                                                                   | Planned disposition                                                                                                                                                                                                          |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| TRELLIS.2             | Microsoft describes a 4B image-to-3D model with base color, roughness, metallic and opacity; Linux/NVIDIA ≥24 GB; MIT model/code with separately licensed rendering dependencies. [Repository](https://github.com/microsoft/TRELLIS.2)                                                                                                                       | First high-quality generator; add explicit normal baking where required, not an invented native normal-map capability.                                                                                                       |
| Original TRELLIS      | Separate project with text/image models and experimental multi-image conditioning. [Repository](https://github.com/microsoft/TRELLIS)                                                                                                                                                                                                                        | Benchmark fallback/native-text and multi-view adapter; never alias its weights or request schema to TRELLIS.2.                                                                                                               |
| Step1X-3D             | Geometry and texture stages; published examples list combined 27/29 GB memory. Apache-2.0 repository; texture dependencies include reused Hunyuan rendering components. [Repository](https://github.com/stepfun-ai/Step1X-3D), [license](https://github.com/stepfun-ai/Step1X-3D/blob/main/LICENSE)                                                          | Alternative geometry/texture candidate after transitive review; do not assume every emitted texture is a complete PBR set.                                                                                                   |
| TripoSG               | Geometry generator; documented minimum 8 GB CUDA VRAM. [Repository](https://github.com/VAST-AI-Research/TripoSG)                                                                                                                                                                                                                                             | Lower-memory geometry candidate plus separately validated texturing. Do not confuse it with Tripo's hosted product or TripoSR.                                                                                               |
| SAM 3D Objects        | Single/multi-object reconstruction with pose/layout; setup specifies ≥32 GB and gated checkpoints; custom SAM license. [Repository](https://github.com/facebookresearch/sam-3d-objects), [setup](https://github.com/facebookresearch/sam-3d-objects/blob/main/doc/setup.md), [license](https://github.com/facebookresearch/sam-3d-objects/blob/main/LICENSE) | Optional admitted reconstruction backend, isolated from the open-core release. Keep mesh and Gaussian-splat outputs distinct.                                                                                                |
| SkinTokens / TokenRig | MIT project providing joint skeleton/weight generation and existing-skeleton skinning; documented ≥14 GB GPU. [Repository](https://github.com/VAST-AI-Research/SkinTokens)                                                                                                                                                                                   | Rigging candidate with transfer and deformation tests; advertised diverse anatomy is not a guarantee for every creature.                                                                                                     |
| MotionGPT3            | Code described as MIT; README explicitly calls out SMPL, SMPL-X, PyTorch3D and dataset licenses. [Repository](https://github.com/OpenMotionLab/MotionGPT3)                                                                                                                                                                                                   | Evaluate text-to-motion and motion editing only after checkpoint/dependency admission.                                                                                                                                       |
| MDM / DiP             | MIT code with separately licensed dependencies/data; DiP is provided within the MDM project. [Repository](https://github.com/GuyTevet/motion-diffusion-model), [DiP guide](https://github.com/GuyTevet/motion-diffusion-model/blob/main/DiP.md)                                                                                                              | Benchmark fallback/streamed motion candidate; do not assume arbitrary nonhuman motion support.                                                                                                                               |
| Paint3D / TEXGen      | Separate mesh-texturing research implementations. Paint3D has an Apache-2.0 code license. TEXGen license/weight clearance was not established by this review. [Paint3D](https://github.com/OpenTexture/Paint3D), [TEXGen](https://github.com/CVMI-Lab/TEXGen)                                                                                                | Evaluate prompt/image-controlled retexturing; unknown rights remain blocked, RGB texturing is not automatically PBR.                                                                                                         |
| Hunyuan3D / HY-Motion | Retained only as comparisons; HY-Motion publishes custom terms. [HY-Motion license](https://github.com/Tencent-Hunyuan/HY-Motion-1.0/blob/master/License.txt)                                                                                                                                                                                                | Excluded from deployment by the prior user decision; no implicit opt-in from the pasted recommendation.                                                                                                                      |
| GPT-6 Astra           | Official model documentation supports text/image input, text output, tool calling and structured outputs. [Model documentation](https://developers.openai.com/api/docs/models/gpt-6-astra)                                                                                                                                                                   | Optional hosted director/critic; frame-based animation inspection plus numerical telemetry. Query capabilities/rates before use; do not hardcode the pasted pricing or assume app orchestration features are API guarantees. |
| BenchCAD              | Execution-verified parametric CadQuery benchmark, not a general textured-character benchmark. [Repository](https://github.com/BenchCAD/BenchCAD-main)                                                                                                                                                                                                        | Use CAD-specific evaluation ideas; no transfer of the pasted model score into release claims.                                                                                                                                |
| Meshy / Higgsfield    | Meshy provides a production generation API; Jutsu documents editable scene objects, timeline/camera controls and revision/export workflows. [Meshy API](https://docs.meshy.ai/en/api/text-to-3d), [Jutsu](https://higgsfield.ai/blog/higgsfield-3d-jutsu)                                                                                                    | Benchmark creation, editability and delivery separately. Reference their workflow capabilities without copying branding or requiring their services.                                                                         |
| Mixamo                | Adobe documents royalty-free use in projects; that alone is not a grant to redistribute a standalone motion library. [Adobe FAQ](https://helpx.adobe.com/creative-cloud/faq/mixamo-faq.html)                                                                                                                                                                 | Compatible user-owned imports; default catalog uses independently cleared clips.                                                                                                                                             |

No exact disk totals or production seconds/$ per asset are asserted here.
Microsoft's published TRELLIS.2 H100 timings are model-stage measurements, not
queue-to-download latency for the Isis pipeline. T.02/T.17 measure downloads,
cold/warm inference, processing, retries, controller usage and complete
delivery.

**2026-09-18, owner decision:** wherever this review says "hosted Astra", the
only route is the Codex CLI on the ChatGPT subscription (`codex exec`), never
the OpenAI API, OpenRouter or any other metered billing. The decision and the
lane that implements it are in the film track (F.01.08, F.01.09).

### Architecture and repository ownership

```text
Existing Isis dashboard / SDK / API
  -> immutable project specification + references + target profile + budget
  -> typed director plan (local controller; optional hosted Astra)
  -> durable stage graph with versioned assets and job cancellation
       -> concept image from Chroma/arsenal -> neural mesh worker
       -> dimensions/components -> Blender / CadQuery / OpenSCAD worker
       -> photo/masks/views -> reconstruction worker
       -> admitted asset and motion libraries
  -> canonical asset manifest + editable scene graph + source artifacts
  -> deterministic geometry/material validation + rendered critic evidence
  -> bounded local repair or replacement, preserving accepted revisions
  -> optional remesh / UV / PBR bake / LOD / collision
  -> optional rig -> diagnostic poses -> motion/retarget/blend -> motion QA
  -> browser scene/timeline + still/video rendering through Isis
  -> verified GLB/glTF/FBX/OBJ/STL/3MF/CAD and engine-specific delivery
```

Canonical interchange is glTF 2.0/GLB plus a versioned asset/scene manifest.
Retain editable `.blend`, procedural scripts/parameters and CAD B-rep sources:
GLB alone cannot preserve a CAD feature tree, Blender constraints or every
engine property. Use typed manifests for capabilities and lossy conversions.

| Existing ownership surface                                                                                            | Extension responsibility                                                                                                       |
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| `apps/isis/generation-api`, `libs/isis/workflows`, `libs/isis/client`, `apps/isis/output-registry`                    | Shared contracts, durable jobs, API/SDK, policy, costs and actual artifacts; add worker kinds rather than a second public API. |
| `libs/isis/3d-generation`, `libs/isis/3d-inference-local`                                                             | Versioned provider adapters and verified model execution; original TRELLIS adapter is not proof of TRELLIS.2 support.          |
| `libs/isis/3d-post-pipeline`, `libs/isis/ai-texturing`, `libs/isis/3d-quality-gates`                                  | Real mesh/texture processing and validation, preserving native materials when valid.                                           |
| `libs/isis/universal-rigging`                                                                                         | SkinTokens, skeleton/skin contracts, motion library, retargeting and deformation QA.                                           |
| `libs/isis/part-level-3d`, `libs/isis/text-mesh-editing`, `libs/isis/3d-scene-assembly`, `libs/isis/3d-asset-library` | Selective edits, semantic scene graph, source assets and revision history.                                                     |
| `libs/isis/model-governance-3d`, `libs/isis/3d-generation-benchmarks`                                                 | Admission, dependency/output rights, evidence, competitive benchmarks and release gates.                                       |
| `apps/isis/web`, `libs/isis/3d-browser`, `libs/isis/llm-providers`, `libs/isis/ai-providers`                          | Existing workspace/viewer and controller integration; reconcile with the shared Eve provider boundary in T.00.                 |
| `infra/runpod`, `docker/runpod`, `scripts/isis`                                                                       | Isolated reproducible worker builds, inventory/library/cache integration, bounded scheduling and operations.                   |

This is an ownership map, not a claim that these packages are production-ready.
A concrete source finding: `WorkflowExecutor.buildThreeDPackageOutput` in
`apps/isis/generation-api/src/workflows/executor.ts` currently synthesizes
texture paths, bundle sizes, fixed mesh statistics and a `storage.example.com`
fallback. T.00.03 removes that behavior before a new 3D workflow can ship.

### Infrastructure and delivery sequence

Proposed worker profiles below are planning defaults, subject to T.02
measurement and the existing spend controls. No endpoints or downloads are
created by this planning change.

| Worker profile         | Proposed resource placement                                                                                                                  | Isolation and billing rule                                                                                                                |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| API/director/scheduler | Existing CPU control plane; separate admitted local LLM/VLM capacity when self-hosted                                                        | GPU mesh workers do not idle while waiting for an LLM. Hosted calls have their own reservations.                                          |
| Geometry/material GPU  | Start admission tests on an available ≥48 GB NVIDIA class for headroom; assess a 24 GB TRELLIS.2 profile and 8 GB TripoSG profile separately | Upstream minima are not production guarantees; actual SKU/runtime/precision determines the catalog profile.                               |
| Rig/motion GPU         | Separate pinned runtime; SkinTokens ≥14 GB upstream minimum, motion memory still to measure                                                  | Share scheduling where ABI and cache compatibility are proven; do not co-load all model families.                                         |
| Reconstruction GPU     | SAM 3D optional, ≥32 GB upstream minimum; trial ≥48 GB profile                                                                               | Separate license/access/runtime admission; open profile has mask-assisted generation and measured multi-view reconstruction alternatives. |
| DCC/CAD/mesh           | CPU workers for geometry/CAD/export, separately scheduled render GPU if needed                                                               | CPU stages have memory/time/process limits; CAD precision may require FP32/FP64 arithmetic. This is not quantized model inference.        |

All generation weights remain full precision under the initiative's existing
rules. Model artifacts live in the Hetzner library; new 3D families rotate
through the **same fixed 400 GB cache**, initially unpinned. Preserve the image/
video pinned core. Include downloaded archives, extraction, temporary bake files
and outstanding leases in the fit calculation. Prevent a second LRU manager in
`3d-inference-local` from independently evicting the shared cache. Split stages
if their required set does not fit; fail with a clear capacity result if
splitting cannot help. Growth requires measured need and a later decision.
Recalculate total Hetzner usage, transfer costs and retention rather than
assuming the earlier account allowance remains sufficient.

Use a dedicated 3D worker kind and private pinned worker images; do not force
native CUDA/CAD dependencies into the working Chroma/video image. Proposed
RunPod defaults are `workersMin: 0`, `workersMax: 1`, idle timeout ≤15 seconds,
and per-stage execution timeout ≤900 seconds. Longer work checkpoints into
bounded stages or remains unavailable until a measured profile is approved. Keep
a separate queue deadline and whole-project wall-time/credit/repair cap. The
global budget and concurrency governor includes existing image/video jobs, so
three individually bounded endpoints cannot multiply spend unnoticed.

| Milestone                       | Required work and dependency order                                        | Exit criterion                                                                                                           |
| ------------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| M0: credible foundation         | T.00 -> T.01; T.02–T.04 after their contract/admission dependencies       | Real artifacts, admitted candidates, bounded workers, persisted revisions and cost reservation.                          |
| M1: first useful vertical slice | T.05 primary path + baseline T.09 + relevant T.15/T.16 + T.17 slice gates | Image -> actual textured GLB -> dashboard preview/download -> re-import, with measured total cost. No director required. |
| M2: editable assets and scenes  | T.06–T.10 + scene portions of T.14/T.15                                   | Text/concepts, procedural/CAD, multi-view/reconstruction, controlled edits and material/LOD/print delivery.              |
| M3: animated characters         | T.11 -> T.12 -> T.13 + animation portions of T.14–T.16                    | Admitted rigs and motion clips, deformation/contact QA, timeline preview and animated exports.                           |
| M4: intelligent production      | T.08 evaluated throughout; T.17 complete -> T.18                          | Controller ablations, honest parity matrix, operations/rollback and per-profile release evidence.                        |

Agent transport qualification is part of those milestones: T.20's headless
runner gates applicable Blender work in M1/M2; live Blender control requires
T.20's MCP session tests; Unity delivery requires T.19; T.21's comparison and
failure tests gate the respective agent-enabled profiles before T.18 rollout.
Unity qualification does not block a Blender/Three.js/Godot-only release.

No milestone inherits completion from an older checkbox or a passing mock.
Optional/research backends may remain unavailable with a recorded reason; that
must not remove the required capability from the release matrix. A capability
without a passing alternative remains an explicit gap, preventing a blanket
parity declaration. Each phase below states dependencies and each task its
verification. Every implementation item remains unchecked until executed.

## T.00 3D scope, reuse audit and trustworthy outputs

Dependencies: existing C/V/A/L decisions; read-only audit can start now.

- [x] **T.00.01** Write the scoped capability/ownership ADR and crosswalk to
      existing Isis 3D TODOs, phase work and Eve tool/provider contracts. Assign
      one canonical implementation owner to each capability; identify obsolete
      wrappers. **Verify:** every capability in T.17's matrix maps to a package,
      task and release gate; no second public job/asset registry is proposed.
      _**Done 2026-09-14 (ADR written; status Proposed for the owner).**
      `docs/domains/isis/adr/ADR-0008-open-3d-studio-capability-ownership.md`:
      each of the 12 capabilities in T.17.06's matrix has exactly one owner
      package (generation-api for agent edits, workspace and API, and
      self-hosting; 3d-post-pipeline for topology, mesh and print exports and
      engine exports; universal-rigging for rigging and motion; one each for
      3d-inference-local, 3d-scene-assembly, video-to-mesh and ai-texturing),
      its T items and its gate, agreeing with the T.00.02 per-library decisions
      (procedural CAD, which T.00.02 did not assess, is assigned with its
      reason). Jobs and chains stay in the generation API, assets in
      output-registry, workflows in the catalog and workflow-registry; five
      alternative entry points are named and forbidden. 23 obsolete wrappers
      with their evidence and removing T item; 58 earlier Isis 3D TODO and phase
      items crosswalked (36 superseded, 13 merged, 8 independent, 1 split);
      director and critic calls go through the shared `@oshun/ai` boundary Eve
      uses. Six capabilities outside the matrix have no gate defined (agent
      transports T.19 to T.21, scene rendering, face and cloth rigging, splats,
      asset-library search, import sandboxing) and sit with 11 open questions
      for the owner in the ADR._
- [x] **T.00.02** Trace dashboard -> API -> adapter -> worker -> persisted asset
      for current 3D generation, processing, rigging and exports. Inspect actual
      callees and tests for simulated results, fixed metrics and missing runtime
      wiring. **Verify:** record runnable paths, concrete defects and
      reuse/repair/replacement decisions with source/test evidence. _**Done
      2026-09-14.** Evidence `docs/agents/isis-3d-studio-evidence.md` section
      T.00.02: 38 paths traced from the dashboard, API, adapters, workers,
      output store and registry through 30 libraries, each with file and line.
      None takes a prompt or image to a stored, verified mesh: 5 are runnable
      (the T.00.03 package builder, which nothing live feeds, and four local
      calculations), 2 partially wired (GLB persistence; a TRELLIS.2 worker
      nothing calls), 6 simulated, 25 dead. 20 defects with the smallest honest
      fix each; the worst: the default image-to-3D workflow's graph ends in
      image saves (spot-checked: Stable Zero123 views, no mesh node) and is
      certified only because the test double returns a GLB for any 3D job; a GLB
      cannot pass the worker adapter, the S3-link labelling or the output store
      (spot-checked: no model mime type); the dashboard shows hardcoded or
      prompt-hash 3D metrics; the 3D licence registry points TRELLIS.2 at the
      original TRELLIS repositories. No Isis app imports any 3D library; eleven
      are reached only from other domains' apps. Each library has a reuse,
      repair, replace or retire decision tied to its T item._
- [x] **T.00.03** Replace synthesized output data in
      `WorkflowExecutor.buildThreeDPackageOutput` with verified worker artifacts
      and parser-derived metadata. Missing textures/bundles are absent or
      errors, never predicted URLs. **Verify:** regressions for no mesh, missing
      texture, malformed GLB, absent bundle and deliberately different mesh
      statistics; successful downloads match recorded hashes, bytes and
      topology. _**Done 2026-09-14.** The old builder invented a
      storage.example.com mesh URL when no mesh existed, fixed polygon and
      vertex counts, five 2048 square textures of 262,144 bytes each, a
      turntable, five engine and DCC bundles with fixed manifests, and eight
      provenance steps that never ran. The package is now built from stored
      worker files only. The mesh bytes are read before storage (data URLs
      decoded, http through the volume fetcher's host allowlist), hashed and
      measured by the API and checked against any hash or size the worker
      recorded; a GLB is parsed by a strict reader (header, chunk layout,
      reference ranges, equal attribute counts, index bounds, POSITION min and
      max against the actual floats) that derives mesh, primitive, vertex and
      triangle counts, materials, texture slots and embedded images, and refuses
      compressed or external buffers. Other formats report format, hash and size
      with stats marked unavailable. Textures, turntable and bundles appear only
      when a real file or embedded image exists. A job with no mesh, an
      unreadable or malformed mesh, a hash mismatch or a missing referenced
      texture fails with a named reason (spend recorded first). Specs: GLB
      reader and package builder with programmatic fixtures for every regression
      the item lists, 324 passing across the touched suites; generation-api tsc
      unchanged at its 9, the executor suite's 11 known failures unchanged.
      Found and left for T.00.02: the worker adapter's base64 path throws on GLB
      bytes, a GLB fetched by S3 link is labelled image/png, the output store
      refuses model files, the output-registry schema still requires textures
      and a turntable._
- [x] **T.00.04** Establish per-capability states: candidate, admitted, wired,
      offline-verified, live-rendered, release-qualified and unavailable with
      reason. Reconcile existing catalog proof fields without treating them as
      quality certification. **Verify:** API/UI cannot promote a stub,
      unsupported model or fixture-only workflow to live-ready. _**Done
      2026-09-14.** One checked-in state machine and registry in
      `libs/isis/workflows/src/three-d-capabilities/` (beside the catalog, as
      ADR-0008 places it; the 3D governance library holds only licence data and
      has a wrong TRELLIS.2 row). Promotions go one rung at a time and each
      needs its own evidence kind: admitted needs pinned revisions and hashes
      with the excluded families refused, wired needs the API entry and dispatch
      site, offline-verified a real spec with a passing count, live-rendered a
      provider job id with the output's type, hash and size of a type the
      capability delivers, release-qualified its T.17.06 gate; unavailable needs
      a reason and evidence, and leaving it restarts at candidate. Records are
      replayed from their evidence, so a state the evidence does not earn is
      refused. Of the 12 capabilities, 3 are candidates and 9 unavailable, each
      with the T.00.02 path and defect ids; none is live-ready. Catalog proof
      levels can only cap a state: validated supports at most offline-verified,
      rendered supports live-rendered only when the graph's save nodes write a
      mesh (the image-saving artifact-reconstruction graph supports nothing),
      and chroma and motion are unchanged. A read-only capabilities route serves
      the registry; a submit, retry, batch, chain or trigger for an unavailable
      or unmapped 3D capability is refused with 422 before any cache lease or
      job row, and other states are labelled not live-ready (a client-typed
      label is stripped), so every 3D job type is now refused at submit rather
      than failing later. The Mesh A/B and Interactive 3D dashboard pages lost
      all fabricated scores, counts, latency, VRAM, previews and progress and
      show the capability states with no measurement instead. Checks: registry
      specs 37; API route, job service, proof level and policy specs 68;
      generation-api tsc at its 9; OpenAPI current; client 365; web page specs
      and tsc clean; chromium desktop and mobile 5; eslint 0 errors._
- [x] **T.00.05** Create T-track evidence/decision records with dated sources,
      exact commands, artifact hashes, costs, failures and dependency blockers.
      Preserve C/V/A/L evidence and image/video delivery order. **Verify:** each
      subsequently completed item has its own evidence; no historical count or
      status badge serves as implementation proof. _**Done 2026-09-14.** The
      T-track record is `docs/agents/isis-3d-studio-evidence.md`, headed by nine
      binding rules: one dated section per item and no close without it, sources
      pinned by commit, revision and read date, exact commands with their
      counts, artifacts by job id and sha256, costs as the C/V/A/L evidence
      records them, failures kept beside successes, blockers named, no proxy
      (checkbox counts, badges, catalog proof levels, model cards, test doubles)
      as implementation proof, and the image and video evidence left
      undisturbed. Decisions go in the Isis ADR folder, starting with ADR-0008.
      Each closed item has its own section: T.00.01, T.00.02, and T.00.03 with
      its commands re-run for the record (42 GLB reader and package specs
      passing) and what it does not claim (no live 3D job, no real worker mesh
      hash)._

- [ ] **T.00.06** _(added 2026-09-18 from the board audit)_ Answer the nine open
      questions of
      `docs/domains/isis/adr/ADR-0008-open-3d-studio-capability-ownership.md`
      section 8 in the ADR itself. They have waited since 2026-09-13, T.20
      shipped past Q5 without its audit, and no tracker item carried them. The
      owner delegated the choice on 2026-09-18; Q5 is already decided (decisions
      block of that date) and gets its table from T.21.07. For Q1–Q4 and Q6–Q9
      pick one of the ADR's own options, give the reason in two or three
      sentences, and name the tracker item that implements it, adding the item
      where none exists. **Verify:** no question in section 8 is left without a
      dated answer; every answer names an item id that exists in this file; the
      ADR's status line says which questions were delegated. 2026-09-19: section
      8 has eleven questions, not nine. Q10 (generation-api's
      `/workflows/catalog` and `apps/isis/workflow-registry` both exist: which
      one do 3D catalog entries and T.00.04's states register in) and Q11 (may
      any T.17.06 row be marked release-qualified before T.00.04's capability
      states ship; the ADR assumes no) fall outside the Q1–Q9 this item lists,
      and its own **Verify** leaves no question unanswered. Answer all eleven,
      the same way.

## T.01 Model, tool and asset admission

Dependencies: T.00; extend A.04 and existing 3D governance, do not fork policy.

- [x] **T.01.01** Produce a pinned manifest for TRELLIS.2, original TRELLIS,
      TripoSG, Step1X geometry/texture and SkinTokens, including every auxiliary
      weight, hash, precision, source revision, code/weight license and runtime
      dependency. **Verify:** admission rejects missing hashes, floating
      revisions, unsupported precision and incomplete dependency closures.
      _**Done 2026-09-14.** `infra/runpod/volumes/isis-3d-models.manifest.json`
      pins seven candidates (TRELLIS.2, TRELLIS image-large, TRELLIS text large
      and xlarge, TripoSG, Step1X-3D geometry and texture, SkinTokens with
      TokenRig) by code commit and 40-hex weight revision, with every file's
      size, LFS sha256, precision, weight and code licence and runtime
      dependencies, read from GitHub and the Hugging Face API (16 revisions
      re-checked, 0 mismatches); it stays separate from the image and video
      manifest until T.02.02 merges admitted rows. The admission check refuses
      missing or malformed hashes, floating revisions (branches, tags, short
      SHAs, unpinned packages, unrevisioned downloads), quantized or unknown
      precision, anything an inference path loads with no pinned row, excluded
      families (all Tencent Hunyuan code) and non-commercial or unknown
      licences, and writes each status itself (a hand-edited status fails a
      test). **All seven are refused, with reasons:** TRELLIS.2 on gated DINOv3
      and RMBG-2.0 hashes, RMBG-2.0's non-commercial licence and nvdiffrast's
      research-only licence; original TRELLIS on a non-commercial Gaussian
      rasterizer and an AGPL mesh fixer; TripoSG and both Step1X-3D parts on
      bundled Tencent Hunyuan code (excluded); SkinTokens only on unpinned
      packages and downloads. Defect D14 is fixed: the governance registry's
      TRELLIS.2 row now cites TRELLIS.2 at its pinned commit and marks
      commercial outputs prohibited, so tests that used it as the permissive
      example now use MeshAnything V2. Checks: admission and capability specs
      65, governance 78, image and video manifest lint unchanged._
- [x] **T.01.02** Review MotionGPT3, MDM/DiP, Paint3D and TEXGen through actual
      inference/download paths, including SMPL/SMPL-X, datasets, encoders and
      rasterizers. Record admitted, replaceable-dependency or blocked outcomes.
      **Verify:** deployable profiles contain only cleared artifacts; a blocked
      candidate has a replacement task/explicit capability gap, not a silent
      skip. _**Done 2026-09-14.** MotionGPT3, MDM, DiP, Paint3D and TEXGen are
      in the 3D candidate manifest with their traced inference paths
      (checkpoints, text encoders, body models, datasets, renderers, compiled
      extensions), and the admission check now computes admitted,
      replaceable-dependency or blocked from a recorded resolution per
      candidate. All five are blocked: the three motion stacks on training data
      and body models whose licences forbid training networks for commercial use
      (AMASS, SMPL, SMPL-X, MANO, read on 2026-09-14) plus unhashed or
      unlicensed checkpoints; Paint3D only on its UV-position ControlNet shipped
      as an unreadable pickle; TEXGen on no code licence, nvdiffrast and a text
      encoder that refuses anonymous reads. Recorded resolutions make TRELLIS.2,
      TRELLIS image, TRELLIS text and SkinTokens replaceable-dependency (still
      not admitted). The deployable profile is empty, and a candidate with no
      recorded gap makes the check fail. Every gap names a task: T.01.06,
      T.01.07, T.10.07, T.10.08 and T.12.07 were added to this tracker for the
      gaps no existing task covered. Checks: capability and admission specs 82,
      remote verification 29 revisions with 0 mismatches, image and video
      manifest lint unchanged._
- [x] **T.01.03** Register SAM 3D as a gated custom-license family and preserve
      the Hunyuan3D/HY-Motion exclusions. Apply policy to tenant catalog, direct
      submission, retries and fallback selection. **Verify:** exclusion tests
      cover API bypasses and dependencies; SAM segmentation admission cannot
      authorize SAM 3D access automatically. _**Done 2026-09-14.** One policy
      list in `@isis/workflows` (`model-family-policy.ts`): Hunyuan3D in every
      version and part, HY-Motion and Tencent Hunyuan, HunyuanDiT or FlashVDM
      code are excluded with no exception; SAM 3D (Objects, Body) is gated, and
      a reference to it is refused unless a checked-in grant accepts the SAM
      License text by its sha256 and records gated access per repository (the
      grant list is empty). SAM 3D Objects is a blocked candidate in the 3D
      manifest (revisions and sizes read anonymously, hashes and dtypes unknown
      because the repositories are gated), and the governance registry has SAM
      3D Objects and Body rows with every right prohibited. Families match by
      their own names, never a `sam` prefix or the shared licence name, and a
      grant built from the admitted SAM 3 and 3.1 rows is rejected at every
      layer. Enforced at submit (so batch, workflow run, chain steps and
      retries, which re-submit and are judged again), the chain route, the
      tenant catalog (hidden from tenants, shown to the operator with the
      reason), execution of a queued job, and every resolver source (override,
      project and system default, scored fallback); the request side reads every
      workflow key the executor reads, project defaults, the job model and
      model-selector parameters, plus the catalog workflow's graph dependencies,
      so an innocuous id loading an excluded model is refused. The capability
      and content-policy guards now also read `metadata.userWorkflowId`, a
      bypass they missed; the Oshun sky-briefing Hunyuan3D fallback is removed;
      the BFF governance admission denies an excluded or ungranted identity
      whatever rights it claims. Checks: policy, admission and capability specs
      103, route spec 15, model-governance-3d 79, BFF 51, remote verification 30
      revisions with 0 mismatches. Not changed: `image-build-config.json` still
      lists the Hunyuan weight for the retired three-d image (editing it on main
      starts a CI image build), and the dead Hunyuan routers in
      3d-inference-local and 3d-generation that no app imports. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.03._
- [ ] **T.01.04** Audit Blender, CadQuery/OpenSCAD, CuMesh, xatlas,
      meshoptimizer, QuadriFlow, optional reconstruction tools, controllers and
      distributed worker dependencies. Produce notices/SBOM and explicit
      output/export rights. **Verify:** open-core deployment has no required
      proprietary service or uncleared executable; Houdini is absent from
      dependencies. _2026-09-14, audit and SBOM done; stays open because the
      verify fails. `infra/runpod/volumes/isis-3d-tools.manifest.json` pins 65
      tool and runtime rows (26 licences, read at the pinned versions, joined to
      the 3D model manifest by 8 row references and the shared licence ids), and
      `three-d-tool-admission.ts` (`--write`, `--check`, `--gate`) computes each
      outcome: floating pins and repository references, unknown or
      non-commercial terms, required proprietary tools without an owner review,
      required network services, GPL or AGPL linked in process, unknown output
      rights, unexpanded dependency lists, refused bundled components, Houdini
      and the excluded families. It generates
      `docs/domains/isis/runbooks/3d-tool-notices.md` and a CycloneDX 1.6 SBOM.
      The Houdini scan over 38 roots (173 dependency files, 103 scripts, 934
      sources) finds no dependency, one label mention. Current verdict: open
      core fails, 11 of 24 required rows pass (no required row is a network
      service or a proprietary engine): Blender is downloaded without a checksum
      and run from PATH, CadQuery/OCP/OCCT and several Python and Node rows have
      unexpanded or unpinned dependencies, CuMesh bundles the non-commercial
      cubvh, and the dev and V1 compose files run `redis:7-alpine` (RSALv2 or
      SSPLv1) and CUDA images under the NVIDIA EULA. Gaps are owned by T.02.01,
      T.20.01, T.20.03, T.01.06, T.06.03, T.06.04, T.07.04, T.19.01, T.16.04,
      T.16.05, T.20.07, T.19.08, T.08.03, T.02.05, T.16.02, T.16.01, T.14.05 and
      T.11.01, and by the new T.01.08 to T.01.12. Checks: tool admission spec
      40, all three-d capability specs 143, lib typecheck clean. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.04._
- [ ] **T.01.05** Register reference assets, HDRIs, motion clips and benchmark
      inputs with redistribution, generation-service and output permissions.
      Reuse A.04 content-policy classifications throughout the 3D chain.
      **Verify:** tenant/internal-only boundaries survive derived meshes,
      retexturing, animation, library reuse and final export. _2026-09-14,
      registry and rule done; stays open until a live 3D path calls the rule.
      `infra/runpod/volumes/isis-3d-assets.manifest.json` registers 22 reference
      assets, HDRIs, motion datasets, benchmark inputs and hosted reference
      outputs with redistribution, generation-service and output permissions and
      an A.04 classification; `three-d-asset-admission.ts` admits 8 (three CC0
      Poly Haven HDRIs pinned by sha256, HumanML3D captions, BenchCAD, and the
      in-repo prompt, image and splat suites) and refuses 14: AMASS, HumanML3D
      motion features and the SMPL-family body models on research-only or
      no-commercial-training terms (as T.01.02 found), CMU on a no-resale clause
      that needs an owner reading, Mixamo, KIT, Tripo, Rodin and Higgsfield on
      unreadable or absent terms, Objaverse and Objaverse-XL on per-object
      licences with no selection, and Meshy on a clause forbidding competitive
      analysis. No HDRI, motion clip or reference mesh file is in the repository
      today. `evaluateThreeDDerivation` (`asset-lineage.ts`) computes a step's
      output class (internal_only if any input is, the highest content rating,
      an unrated upload counted explicit), refuses a tenant any internal_only
      lineage (403), refuses crossing tenants for every actor, refuses racy or
      explicit inputs to an sfw_only step (422) and refuses delivering an
      internal_only output or a non-redistributable embedded file to a tenant or
      the shared catalog. Specs cover derived meshes, retexturing, animation,
      library reuse and final export with a tenant and an operator (46 new, 189
      across the capability specs). Every 3D job type is still refused at submit
      and the asset library has no app importer, so nothing enforces the rule
      live yet; the items that must call it are T.03.01, T.03.02, T.03.05,
      T.04.02, T.04.05, T.04.06, T.05.01 to T.05.04, T.07.03, T.10.02, T.10.03,
      T.10.05, T.12.03, T.12.04, T.13.01, T.14.01, T.14.05, T.16.01, T.16.06,
      T.17.01 and T.17.02. New gaps: T.01.13 to T.01.17._
- [ ] **T.01.06** _(added 2026-09-14 from T.01.02)_ Replace the research-only or
      unlicensed rasterizers, segmenters and encoders on the 3D paths
      (nvdiffrast, the cubvh sources under the NVIDIA instant-ngp licence,
      mip-splatting diff-gaussian-rasterization, RMBG-1.4, diso, and the CLIP
      conversions with no licence) with cleared components already pinned
      (kaolin, BiRefNet) or obtain commercial licences. **Verify:** admission
      re-run on the replaced rows passes every rule, and a quality comparison
      against the upstream component is recorded.
- [ ] **T.01.07** _(added 2026-09-14 from T.01.02)_ Owner decisions that change
      remote state or accept terms: request gated DINOv3 access and record its
      hash and dtypes, decide the AGPL pymeshfix question, and ask the
      MotionGPT3 and TEXGen authors for licence texts. **Verify:** each decision
      is recorded with its date and source, and the admission check is re-run on
      the affected candidates. _2026-09-14, from T.01.03: accepting the SAM
      License and requesting gated access to facebook/sam-3d-objects,
      facebook/sam-3d-body-dinov3 and facebook/sam-3d-body-vith is also an owner
      decision here; it lands as a grant in `model-family-policy.ts` whose
      record points at the dated evidence entry._ _2026-09-14, from T.01.04:
      accepting the NVIDIA CUDA EULA and the NVIDIA Deep Learning Container
      License for the CUDA base images is also an owner decision here (not read
      yet)._ _2026-09-14, SAM 3D: the user reports accepting the SAM License ("i
      accepted the sam 3d license"). Checked the same hour with the Hugging Face
      token in the owner's environment: all three gated repositories
      (facebook/sam-3d-objects, facebook/sam-3d-body-dinov3,
      facebook/sam-3d-body-vith) still answer 403 on a gated file, so access for
      that account is not granted yet (manual approval), or the licence was
      accepted on another account. No grant is written to
      `model-family-policy.ts`: a grant needs the granted repositories as well
      as the accepted licence text, so SAM 3D stays refused until a re-check
      returns 200, when the grant, its hashes and dtypes and a re-run of the
      admission check land together._ _2026-09-15 re-check, same token: a ranged
      read of a config file in each of the three repositories answers 403 with
      `x-error-code: GatedRepo` ("you are not in the authorized list"); only the
      ungated LICENSE and README read. No grant written._ _2026-09-18, board
      tag: every part is an owner act (accept terms, request access, ask the
      authors) or the vendor's manual approval of the gated SAM 3D repositories,
      which still answered 403 on 2026-09-15._ `blocked:human`
      `blocked:external`
- [x] **T.01.08** _(added 2026-09-14 from T.01.04)_ Replace Redis 7.4+ in the
      open-core compose files (`redis:7-alpine` resolves to RSALv2 or SSPLv1)
      with Valkey (BSD-3) or a pinned Redis 7.2, pinned by digest, and re-run
      the tool gate. **Verify:** the tool check passes the row, and the queue
      and cache specs that use Redis pass against the replacement. _**Done
      2026-09-15 on the owner's decision ("Valkey, flush at cutover").** Both
      open-core compose files now run `valkey/valkey:8.1.10-alpine` pinned by
      digest `sha256:d2e18f34…` (BSD-3, COPYING at commit 55a54267 read and
      hashed), with `valkey-server` and a `valkey-cli` healthcheck. The service
      keeps the name `redis`, so every `REDIS_URL` resolves unchanged. Each
      mounts a NEW volume (`valkey_dev_data`, `valkeydata`) because Valkey
      cannot read Redis 7.4's RDB v12; the old volumes stay for rollback, and
      the V1 README gained a cutover section (drain the queue, deploy, check,
      what the flush loses). The tool row is now `valkey` with an expanded
      closure (jemalloc, hiredis, linenoise, lua, hdr_histogram, fpconv,
      fast_float, each licence read from its own file) and **passes the tool
      check**; open core went from 11/24 to 12/24. Checks: the dev stack was cut
      over (`valkey-cli ping` → PONG, `valkey_version:8.1.10`), and against it
      the BFF live-Redis integration specs pass 20 (idempotency, abuse
      protection, SSO and LTI login state, cycle lease, Telegram claim,
      generation admission, render budget) and the generation API's ledger,
      rate-limit and queue specs pass 47. Other domains' compose files
      (saraswati, cybele, lakshmi, v3, v6, psyche, test) still name
      `redis:7-alpine` and are outside this item._
- [x] **T.01.09** _(added 2026-09-14 from T.01.04)_ Review the GPL code imported
      in process, PyMeshLab in `mesh_processing_pipeline.py` and bpy in the
      SkinTokens path: move each behind a separate process boundary or record an
      owner decision on distributing it. **Verify:** the tool check's
      `copyleft_linked_review` clears for both rows. _**Done 2026-09-16 on the
      owner's decisions:** replace PyMeshLab rather than ship a GPL helper ("GPL
      we distribute: none"), and bind bpy to a separate process before anything
      imports it. **T.01.04 had undercounted PyMeshLab** — its row named the GPU
      worker pipeline and three runners, but `import pymeshlab` had **six**
      sites doing three different jobs. The four quadric-decimation sites (three
      TripoSG runners and MeshAnything topology cleanup) now use Open3D's
      `simplify_quadric_decimation`, the same algorithm, with one documented
      approximation stated beside the constant in each file: PyMeshLab merged
      close vertices by a percentage of the bounding-box diagonal, Open3D takes
      an absolute epsilon, so each runner applies `1e-4` of the computed
      diagonal. Three sites refuse instead, none a silent loss: FBX/USD export
      is refused **before the mesh is loaded**, so a job that cannot be
      delivered does not spend the work first (T.16 owns verified export);
      MeshAnything V2 edge flow has no Open3D equivalent for isotropic remeshing
      and is **not an admitted family** (98 unreachable lines and the dead
      filter dispatcher removed, band and OBJ helpers kept for T.09.03); and the
      Hunyuan3D quad conversion belongs to an **excluded** family (A.04.04), so
      refusing is more correct than before — two loader warnings that claimed it
      "is implemented as a PyMeshLab post-process" were corrected before they
      became false. `Dockerfile.mesh-processing` and both TripoSG install plans
      now carry `open3d`, not `pymeshlab`. **bpy** has no importer at all
      (`planned`, empty references), so the row binds the design instead of
      leaving it open: the SkinTokens export drives Blender as an executable, so
      `usage` is `separate-process`, and returning to `linked-library` is stated
      to need an owner decision (T.01.07). `grep -rn "import pymeshlab"` now
      returns **0**; the pymeshlab row and its orphaned licence entry are gone
      (61 → 60 rows) and bpy keeps only `closure_unexpanded` and `pin_floating`,
      which are T.02.01's. **No row raises `copyleft_linked_review`**, and the
      spec now asserts that for every row rather than asserting PyMeshLab's old
      refusal. Checks: `--check` exit 0, overall 21/60, open core unchanged at
      12/24; 3d-inference-local 403, three-d-capabilities 224, gpu-worker 30,
      lib tsc clean, every touched Python compiles, adversarial grep clean. Not
      claimed: no mesh was decimated on hardware here (Open3D is not installed
      on the Mac and the runners need CUDA), so the equivalence rests on the
      algorithm and the stated epsilon difference, not a measured comparison —
      T.05's first run should record one. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.09._
- [x] **T.01.10** _(added 2026-09-14 from T.01.04)_ Replace or remove the
      graphdeco Gaussian splatting worker (its code, rasterizer and simple-knn
      are non-commercial); T.01.06 names only the mip-splatting rasterizer.
      **Verify:** no open-core or optional row carries a non-commercial licence
      for splatting, and a quality comparison is recorded if replaced. _**Done
      2026-09-16 by removing it, so no comparison is owed.** A replacement would
      owe this item a measured quality comparison, which needs a GPU render
      nobody has approved; removal ends the exposure now and nothing live was
      lost — T.00.02 recorded the worker as path P16, dead, no producer, and C3
      was already `unavailable`. Deleted: the Dockerfile that cloned graphdeco
      gaussian-splatting, diff-gaussian-rasterization and camenduru/simple-knn
      at their default branches, the 427-line executor, the 321-line pipeline
      that ran `convert.py` and `train.py`, and its test double; with them the
      worker-type union and schema entry, the executor import and export, the
      `docker build` command and the throughput target and benchmark case.
      **T.01.04 had missed a second caller:** `training-manager.ts`'s
      `SubprocessTrainingBackend` defaulted to
      `/opt/gaussian-splatting/train.py` when `GAUSSIAN_SPLATTING_PATH` was
      unset — the path that image created. Isis now bundles no trainer and
      builds no image that fetches one; unset fails loud with `not_configured`
      naming the licence and this item (4 new specs, one checked against a wrong
      matcher so it is not vacuous). The library itself stays: T.00.02 decided
      repair for T.07. The three rows and the `Gaussian-Splatting-License` entry
      are gone from the tool manifest (65 → 62 rows), which also cleared a
      floating repo reference from `colmap`, `ffmpeg` and `nvidia-cuda-images`
      (6 → 5); notices and SBOM regenerated; `--check` exit 0; open core 12/24
      unchanged, overall 20/62. Splatting is not replaced — C3 stays
      `unavailable` and now records why. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.10._
- [x] **T.01.11** _(added 2026-09-14 from T.01.04)_ Pin MinIO by digest (the V1
      box uses `latest`) and record its AGPL obligations, or replace it.
      **Verify:** the MinIO row passes the tool check. _**Done 2026-09-15, and
      the pin moved registry.** `minio/minio:latest` on Docker Hub **denies
      anonymous pulls** — a fresh host gets "authorization failed" (checked
      2026-09-15; `busybox:latest` pulls fine from the same machine, so it is
      the repository, not a rate limit). A V1 box rebuilt today would fail to
      start MinIO. Both open-core compose files now use
      `quay.io/minio/minio@sha256:14cea493…` (tag RELEASE.2025-09-07T16-13-09Z,
      source commit 01ce918d), and the row records the AGPL obligations: run
      unmodified as a separate process, so §13 adds no source duty for the
      caller, with the licence text and CREDITS shipped in the image. The
      closure is the CREDITS vendor notice (1.88 MB, hashed). The MinIO row now
      **passes** the tool check; open core stays 12/24, overall 19 to 20/65. The
      dev container was recreated on the pinned image and answers
      `/minio/health/live` with 200. Other domains' compose files still use
      `minio/minio:latest` and are outside this item — they will hit the same
      pull denial._
- [x] **T.01.12** _(added 2026-09-14 from T.01.04)_ Decide whether nerfstudio
      (the NeRF manager) and onnxruntime-node (in a module T.00.02 marked for
      replacement) stay; remove them or complete their rows. **Verify:** each is
      either gone from the repository's 3D paths or passes the tool check.
      _**Done 2026-09-16; the two went opposite ways.** **nerfstudio: removed.**
      Its only reference was the NeRF manager resolving `ns-process-data`,
      `ns-train` and `ns-export` from PATH over an unlisted torch/gsplat/
      tiny-cuda-nn closure. Completing that row would admit a large research
      closure for a lane the plan does not have — the reconstruction lane is
      COLMAP, multi-view and optional SAM 3D, and the row itself recorded
      `noItem`. Nothing imported the manager, it exported its `Mock*` backends
      as public API, and it carried **D13**: with no checkpoint
      `exportAsPointCloud` wrote a Fibonacci-sphere PLY and returned success as
      `generated-point-cloud`. Deleting the module (62 KB + its test + the two
      barrel export blocks, replaced by a comment saying what went and why)
      closes D13 with it. No `ns-*` invocation remains in `libs` or `apps`; the
      surviving `'nerfstudio'` strings are dataset-format literals in type
      unions. C3's reason, which cited the manager, was updated.
      **onnxruntime-node: kept, row completed** — removing it now would pre-empt
      T.10.06/T.09, which own the upscaler's fate. Finding on the way: the npm
      package **ships no notice file at all** (installed 1.23.2 has only README,
      bin, dist, lib, package.json, script) while shipping prebuilt
      `libonnxruntime` binaries, so a distributor must carry notices from
      elsewhere. The closure is now a `vendor-notice` pinned to the matching
      source tag (326,866 bytes, sha256 `e9e90971…`, read 2026-09-16) naming 59
      components; two are not permissive and are recorded — Eigen MPL-2.0 and
      Intel MKL under the Intel Simplified Software License — and the file's one
      "GNU General Public" hit is inside MPL 2.0's "Secondary License"
      definition, not a bundled GPL component. Not claimed: which subset is
      linked into each prebuilt binary per platform. Checks: `--check` exit 0,
      `onnxruntime-node` **passes**, manifest 62 → 61 rows, overall 20/62 →
      21/61, open core unchanged at 12/24 (both rows optional); gaussian-
      splatting 406, three-d-capabilities 224, lib tsc clean. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.12._
- [x] **T.01.13** _(added 2026-09-14 from T.01.05)_ Give the Mixamo, CMU and KIT
      licence policies written into
      `libs/isis/universal-rigging/src/motion-licensing-provenance.ts` dated
      sources, or replace them with the asset registry's rows. **Verify:** every
      policy there cites a registry row or a dated source. _**Done 2026-09-15.**
      Each policy in `motion-licensing-provenance.ts` now carries a
      `sourceReference`: the asset-registry row id, the url its terms were read
      from and the read date, and the record it emits carries them too.
      `motion-licensing-provenance-sources.spec.ts` fails if a policy names a
      row the registry does not have, or if the url or date drifts from that row
      (12 specs pass)._
- [x] **T.01.14** _(added 2026-09-14 from T.01.05)_ Owner reading of the CMU
      motion capture terms: does a hosted service returning retargeted clips
      count as resale "in converted form"? **Verify:** the decision is recorded
      with its date and the CMU row is re-run. _**Done 2026-09-15 on the owner's
      decision.** Asked with the CMU no-resale term as the premise, the owner
      answered "Yes, treat as resale": a hosted service returning retargeted CMU
      clips is reselling the data in converted form. The CMU policy now
      prohibits product export and marketplace redistribution (internal rigging
      stays allowed), records the decision with its date and item, and its
      summary, allowed uses and restrictions say so; the registry row carries
      the same decision and its refusal stands. Mixamo's export verdict is
      unchanged, so the decision is CMU's alone (specs both ways)._
- [x] **T.01.15** _(added 2026-09-14 from T.01.05)_ Drop Meshy from the T.17.02
      comparison set or obtain written permission for competitive analysis.
      _2026-09-15: the owner wants Meshy as an optional production lane within
      its terms (T.22), which rules out using it as a comparison input without
      written permission._ **Verify:** the Meshy row is admitted or absent from
      every benchmark input. _**Done 2026-09-15.** Meshy is absent from every
      benchmark input. `libs/isis/3d-generation-benchmarks` lost its Meshy
      runner, its exports, and its renderer order and colour. Tests that used
      Meshy as the example competitor now use Tripo, Rodin or `local` and assert
      the same behaviour. A new `competitive-analysis-exclusions.spec.ts` parses
      the lib's sources with the TypeScript parser and fails on Meshy in code,
      in an export or target id, or in a comment that does not cite T.01.15 (lib
      58 tests pass). The asset registry's Meshy row stays refused and now cites
      T.01.15 and the owner decision instead of the deleted runner; the asset
      check runs (8 admitted, 14 refused). Phase 71's 71.7.3.1 is unchecked with
      the retirement recorded._
- [x] **T.01.16** _(added 2026-09-14 from T.01.05)_ Training-data rights for the
      3D model candidates T.01.01 and T.01.02 deferred, per candidate rather
      than at the Objaverse collection level. **Verify:** each candidate's
      training data terms are recorded and the admission check reads them.
      _**Done 2026-09-16.** Ten candidates' papers, cards, object lists and
      dataset terms read the same day. Where a candidate published its list it
      was joined to Objaverse-XL's per-object licences: non-commercial Creative
      Commons objects make up 11.36% of TRELLIS-500K's Sketchfab list, 6.71% and
      5.86% of Step1X-3D's, 13.27% of Paint3D's and 4.29% of
      Articulation-XL2.0's Sketchfab rows, and 87–89% of the GitHub lists carry
      no licence value; no candidate states a licence filter. HSSD, 3D-FUTURE,
      ShapeNet and BDD100K are non-commercial, VRoid Hub's terms restrict
      learning to develop AI without the poster's permission, and unpublished
      subsets and unreadable terms are unknown; ABO, ProcTHOR, SA-V and Ego4D
      clear. The model manifest records 27 training licence rows, training data
      on 37 own weight files and an evidence block per candidate, and the
      `training_data_licence` rule reads them (one refusal per licence that does
      not clear). TRELLIS.2, TRELLIS image and text and SkinTokens are now
      blocked by their own weights; every gap names T.01.18. Checks: model check
      exit 0 (only training-data reasons changed), capability specs 297, tool
      and asset checks unchanged. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.16 and
      `docs/agents/evidence/isis-3d-studio/t0116/`._
- [x] **T.01.17** _(added 2026-09-14 from T.01.05)_ Reconcile
      `libs/isis/3d-asset-library/src/license-assignment.ts`'s licence
      vocabulary with the asset registry and lineage rule. **Verify:** the asset
      library classifies imports with the registry's classes and a spec shows
      it. _**Done 2026-09-16.** Every licence plan now carries a
      `registryClassification`: the registry's licence class, its three
      permission statuses, the A.04 distribution tier and the conditions.
      Reading the two vocabularies side by side found **four defects**: every
      `CC BY-*` deed was read as plain `cc-by`, so **`CC BY-NC` came out
      commercially usable** and share-alike and no-derivatives were lost (no
      library kind could express them); the uncommitted draft classifier ranked
      share-alike above non-commercial (so NC-SA became `copyleft`, which the
      registry admits); it put `service` distribution on a licence with
      derivatives prohibited, which the registry refuses as
      `distribution_exceeds_permission`; and it allowed generation-service use
      of non-commercial assets. New `cc-by-sa` and `cc-by-nd` kinds,
      element-wise Creative Commons inference, a restrictive-first classifier
      (`service` only when all three permissions grant), and the four variation
      modules' warnings handle the new kinds. The spec runs each of the 576
      kind-and-policy classifications through the registry's own evaluator and
      the lineage rule, and classifies the checked-in registry's 22 rows: the 14
      the library can express match class, statuses and distribution exactly;
      the 8 it cannot (MIT, Apache-2.0, CMU, Meshy, Objaverse) come out
      `unknown`/`internal_only`. Checks: spec 27 (13 and 2 fail with the fixes
      reverted), lib 140, lib tsc clean, eslint 0 errors. Not claimed: no live
      importer calls it yet (T.04.02, T.04.06). Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.01.17._
- [ ] **T.01.18** _(added 2026-09-16 from T.01.16)_ Owner decision on how
      training-data rights bind 3D weights. Every self-hosted 3D generator,
      texturer and rigger reviewed is trained on per-object Creative Commons
      collections that include non-commercial objects with no licence filter,
      GitHub objects with no recorded licence, research-only datasets (HSSD,
      3D-FUTURE, ShapeNet) or VRoid Hub models under an AI-learning restriction.
      Options: treat the weights as bound by their training data (current rule:
      all refused, C1 through the hosted Meshy lane only), accept a documented
      risk for `internal_only` use, obtain commercial terms, or train or adapt
      on cleared data (ABO, CC0 and CC BY objects, licensed captures).
      **Verify:** the decision is recorded with its date and source, the
      admission rule encodes it, and the model check is re-run on every
      candidate. _2026-09-18: **decided under the owner's delegation** (the
      decisions block of that date, first bullet): such weights are admitted as
      `internal_only` and refused for any tenant-facing or catalog delivery.
      What is left is engineering and an agent can do it: (1) add an
      `internal_only_training_data` outcome to the `training_data_licence` rule
      in `libs/isis/model-governance-3d` so a candidate whose only refusals are
      training-data refusals is admitted with `distribution: internal_only`
      instead of refused; (2) record the decision, its date and this item as the
      rule's source in `model-family-policy.ts`; (3) add specs both ways — an
      internal_only candidate is admitted for an operator job, and a tenant job,
      a catalog promotion and a delivery of its output are each refused by
      `evaluateThreeDDerivation`; (4) re-run the model check and record the new
      verdict for TRELLIS.2, TRELLIS, SkinTokens, Step1X-3D and Paint3D in
      `docs/agents/isis-3d-studio-evidence.md`. T.05.01, T.05.04, T.05.05,
      T.10.07 and T.11.01 stop waiting on this item once (4) is recorded._

## T.02 Reproducible workers, model library and capacity

Dependencies: T.01 per family; L.01–L.04 library/cache contracts.

- [ ] **T.02.01** Build minimal private Linux geometry/material, rig/motion and
      DCC/CAD worker images from pinned dependencies, splitting incompatible
      CUDA/Python stacks. Keep weights out of images and builds off the Mac.
      **Verify:** CI rebuild, model-free boot, runtime/version probes and image
      inspection; image/video worker images remain independently deployable.
- [ ] **T.02.02** Extend the Hetzner manifest and cache family graph with exact
      remote bytes/checksums and separate geometry, texture, rig and motion
      dependencies. **Verify:** real library upload/download hash agreement; no
      metadata/weight downloading on request paths outside managed sync.
- [ ] **T.02.03** Integrate all 3D workers with L.03 leases and one eviction
      authority. Include scratch/extraction space, temporary copies and render
      outputs in admission. **Verify:** concurrent image/video/3D leases, disk
      exhaustion, interrupted sync and whole-family admission never evict active
      files or exceed 400 GB; rejected plans explain the bytes needed.
- [ ] **T.02.04** Measure each admitted runtime on actual GPU SKUs: cold/warm
      peak VRAM/RAM, precision, disk, model load, inference, export and output
      size at supported resolutions. **Verify:** publish measured envelopes and
      OOM boundaries; reject oversized jobs before dispatch with explicit
      lower-resolution alternatives, never automatic quantization.
- [ ] **T.02.05** Provision bounded 3D endpoint profiles and CPU workers with
      health checks, readiness, drain, execution/queue limits and inventory
      drift detection. **Verify:** a model-free job, timeout/cancel and
      scale-to-zero; apply the existing endpoint diagnostic sequence before
      rebuild/migration.
- [ ] **T.02.06** Prove first-family miss -> sync -> inference -> upload and
      subsequent warm reuse alongside an existing image/video workflow. Measure
      cache churn and account-wide storage/egress. **Verify:** artifact/cost
      receipts, released leases and no regression of pinned-core generation; new
      3D working set fits or has an explicit capacity blocker.

## T.03 Shared contracts, durable stages and bounded spending

Dependencies: T.00; T.02 admission metadata for dispatch.

- [x] **T.03.01** Extend API/OpenAPI/client/workflow schemas for 3D requests,
      target profiles, references/views/masks, dimensions, source assets,
      material/rig/motion controls and stage capabilities. Audit persistence
      enum/check constraints, including the video-to-video mismatch recorded in
      L.06.04. **Verify:** valid round trips, migration compatibility and
      rejection of invalid types/units/capability combinations before GPU work.
      _**Done 2026-09-16.** `parameters.threeD` (`request-contract.ts` in
      `@isis/workflows`) states profile, stages, geometry method, views with
      role, label, mask and camera, a source asset revision, dimensions with
      unit, basis and tolerance, scale anchors, and material, rig, motion,
      export and director controls, in strict objects. The API parses its shape
      (400), then `evaluateThreeDJobRequest` refuses every undeliverable
      combination at once (422 `three_d_request_invalid`, 31 issue codes: stage
      dependencies, profile bounds, view and camera errors, units and bases,
      export formats that cannot carry the requested rig or motion), before the
      cache or a job row; each stage maps to its capability and an unavailable
      one is refused naming the stage, on submit, batch, retry and every chain
      step. OpenAPI gains the component generated from zod (a spec fails on
      drift), the client SDK the type (the API's `tsc` fails on any field
      difference). **The L.06.04 cause:** the jobs table's inline
      `jobs_type_check`, frozen when the table was first created, sat beside the
      rebuilt constraint and refused `video-to-video` on the dev database; the
      cache events' kinds and families' states had the same defect. All three
      are now rebuilt from code on start. Checks: contract 49 (workflows 1413),
      route 6, OpenAPI 6, real-Postgres 14 (3 of the 4 new fail with the drops
      reverted), client 365, API tsc 8 errors none touched, eslint 0 errors; 5
      chain-advancer failures and one import error in the affected suites
      predate this change. Not claimed: no 3D stage runs; the source asset's
      representation is unverified until T.04.01. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.03.01._
- [x] **T.03.02** Implement persisted stage DAGs using existing jobs/chains:
      dependency hashes, provider IDs, progress, leases, cancellation and
      resume-from-checkpoint. **Verify:** crash between dispatch and
      persistence, duplicate/out-of-order callbacks and retries do not create
      duplicate expensive stages or falsely complete a parent job. _**Done
      2026-09-16.** A `parameters.threeD` parent becomes a stage DAG
      (`stage-graph.ts`); one row per stage in `three_d_stage_runs` holds the
      dependency hash, dispatch token and lease, child job id, provider task id
      and checkpoint, progress, measured output hash, attempt and typed error,
      changed only by `applyStageEvent` under a row lock. Each execution is an
      ordinary job submitted under a key built from parent, stage, attempt and
      dependency hash, so the job service's unique idempotency index — not
      memory — decides whether it exists: a dispatcher killed between submit and
      recording leaves a lease whose re-dispatch returns the same job, and a job
      that finished unrecorded is adopted. Repeated, late, cross-job and
      earlier-attempt callbacks are duplicates or stale; a parent completes only
      when every stage succeeded with measured outputs. Retryable failures are
      retried before the parent settles, up to a per-stage bound, one attempt
      per failure across processes; cancel stops running stage jobs; the inline
      runner hands parents to the graph, reports stage jobs after they are
      stored, resumes graphs on start and sweeps expired leases. Found on the
      way: a client could pose as a stage job; its descriptor is now stripped
      and the `3d-stage:` key refused (422). Checks: graph 19, orchestrator 12
      over the real JobService (the crash spec fails when the key includes the
      dispatch token), live Postgres 6 (racing leases, 5x redelivery, completion
      racing cancel), runner 18, workflows 1432, API tsc 8 errors none touched,
      eslint 0 errors; the full API suite's 24 other failures predate this. Not
      claimed: no stage has run on a worker (every capability is unavailable or
      a candidate); rig, motion and retarget have no job type. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.03.02._
- [x] **T.03.03** Reserve a conservative project budget across concept images,
      GPU/CPU stages, controller calls, retries and repairs; settle real charges
      and release unused reservations. **Verify:** concurrent submissions,
      unknown prices, failed jobs and delayed billing cannot overrun tenant/day/
      project caps; failed-attempt costs remain visible. _**Done 2026-09-16.**
      Every stage attempt (the concept image included; controller and repair
      purposes exist for T.08) reserves its configured price ceiling in
      micro-USD against the 3D day, the verified tenant's day and the project (a
      request's `budget.maxUsd` only lowers the project cap) before its job
      exists; a stage with no ceiling, unset caps or no verified tenant is
      refused. Held and awaiting-billing reservations count their estimate, so a
      failed job or a late charge never frees money; a settled one counts the
      charge, overrun included; only work that never started is released; the id
      replays after a crash. Postgres serializes on the scope rows. Settled from
      recorded `costUsd`, late charges through `recordStageCharge`, and
      `GET /api/v1/jobs/:id/three-d-budget` shows every attempt and scope (503,
      not zero, when unreadable). Fixed on the way: a stage refused during
      dispatch left its parent running. Checks: orchestrator 19, live Postgres 5
      (20 concurrent $1 reservations under a $5 cap admit exactly 5; with the
      locks removed the spec fails), budget route 2, affected API suites 725,
      workflows capability 292, API tsc 8 errors none touched, eslint 0 errors.
      Not claimed: no real charge has settled a reservation; late charges are
      not fed automatically yet. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.03.03._
- [x] **T.03.04** Enforce global resource/concurrency and stage/retry/repair
      limits across image/video/3D workers, with fair scheduling and no polling
      GPU allocation during CPU/LLM waits. **Verify:** DAG fan-out remains
      within aggregate caps; cancellation stops pending work and kills active
      process groups, preserving incurred charges and resumable artifacts.
      _**Done 2026-09-16.** Every stage job holds one slot of its class
      (`gpu-image`, `gpu-video`, `gpu-3d`, `cpu-dcc`, `controller`) from
      dispatch until its job is terminal, never beyond the class's configured
      capacity; an unconfigured class runs nothing. A parent holds no slot, so a
      graph waiting on CPU or controller work keeps no GPU. A freed slot goes to
      the tenant holding fewest, then longest waiting, and waiting parents are
      advanced in that order. Fan-out per parent and automatic retries per stage
      and per parent are bounded; repair loops do not exist until T.08. Cancel
      stops running stage executions and provider jobs and frees slots, keeping
      finished outputs and settled charges. GPU-worker tools now run as process
      groups: SIGTERM, then SIGKILL after a grace period, settling only after
      the group exits (Blender used to SIGTERM only its direct child and clean
      up underneath it). Fixed on the way: Blender progress skipped frames
      batched in one chunk. Checks: process groups 5 on real processes (3 fail
      when only the leader is signalled), gpu-worker 35, orchestrator 26
      (fairness spec fails on plain FIFO), live Postgres governor 5 (over-grants
      without the lock), affected API suites 71, tsc clean or unchanged, eslint
      0 errors. Not claimed: image and video jobs outside a 3D graph take no
      slot yet. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.03.04._
- [x] **T.03.05** Add typed stage errors, idempotent API controls and signed job
      events/webhooks for partial, failed, cancelled and complete results.
      **Verify:** stale revisions, missing assets, license rejection, exhausted
      budgets, queue timeouts and unavailable backends have distinct actionable
      outcomes; SSE reconnect and webhook replay preserve correct state. _**Done
      2026-09-16.** Every stage error code falls into one of eleven categories,
      each with a status, a retryability and a next step. The six named cases,
      reached through the real JobService, end as `asset_missing`,
      `licence_rejected`, `budget_exhausted`, `backend_unavailable`,
      `queue_timeout` and `revision_stale`, with six different next steps. A
      stage job queued past its limit is cancelled, its slot freed and its
      reservation settled at zero. A stage retry keyed by the attempt it retries
      answers 202 once and 200 after; a stale `expectedSequence` gets 409
      `revision_stale`. A per-parent event log (deduped, gapless sequence, each
      event holding a snapshot of the whole graph read under the append lock)
      feeds SSE and signed webhooks. SSE resumes from `Last-Event-ID`. Webhooks
      go through an outbox with each subscription's own backoff, end dead when
      attempts run out, and can be redelivered under the original event id.
      Found on the way: a failure retried within the same advance was never
      published. Checks: orchestrator 33, errors 6, delivery 5 (a receiver sees
      1, 3, 4, 2 plus replays and ends on the last snapshot), live Postgres
      events 2 (fails with the snapshot read outside the lock), routes 8 (the
      SSE reconnect crosses a closed stream), related suites 109 plus live
      stores 66, tsc unchanged, OpenAPI check up to date. Not claimed: no
      delivery to a real receiver, SSE polls rather than listening, and routes
      do not check job ownership. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.03.05._
- [x] **T.03.06** Sandbox imports and procedural/model execution: non-root,
      bounded CPU/memory/files/processes, no host mounts/secrets, disabled blend
      auto-execution, controlled network fetches and expiring artifact access.
      **Verify:** malicious archives, external glTF URIs, traversal, SSRF,
      fork/memory bombs and imported-script execution fail before harm. _**Done
      2026-09-16.** Blender, the mesh pipeline and the upscaler run through
      `runSandboxed` in `apps/isis/gpu-worker/src/sandbox/`. Each run gets a
      leased uid with no root groups and a fixed environment with no secrets.
      Its job directory is made 0700 and handed to that uid, hard-linked files
      excepted. Rlimits (CPU, file size, open files, processes, address space on
      Linux) are set before exec, resident memory is sampled, a wall clock is
      enforced, and processes that escaped the group are swept before the uid is
      released. Inputs are fetched by `safeDownload`: private, metadata and
      IPv6-mapped addresses are refused at connect time and on redirect, the
      body is capped, and the whole download has a deadline. Zips are checked in
      full before any write. Meshes are refused if any reference escapes on any
      reading trimesh or another parser could take (glTF, OBJ, MTL, PLY), and
      formats with unchecked references are refused. Blender runs with
      `--factory-startup --disable-autoexec` and `--python-exit-code`, and
      renders nothing that reads a file outside its scene's directory. Artifact
      URLs from the output registry are now real Signature V4 presigned URLs
      (60–3600 s), only for server-chosen keys under the owner's upload prefix,
      with an upload's type and size signed; before, the registry returned a
      `storage.local` URL whose "signature" was base64 of id and expiry.
      **Defects found:** that forged signature; five reference escapes trimesh
      4.12.2 followed into an exported GLB (PLY `TextureFile`, a spaced
      `map_Kd`, a commented `mtllib`, a line-continued `mtllib`, MTL maps
      resolved from the OBJ's directory); Blender ignoring settings-script
      errors; job files readable across runs; hard links chowned to the sandbox
      uid; `[::127.0.0.1]` allowed; downloads with no overall deadline; a uid
      released after a failed sweep; whole archives held in memory; and
      process-group runs hanging when macOS answered EPERM under load (T.03.04
      code, 2 suite runs in 3). **Checks:** gpu-worker 76 in 5 consecutive runs,
      including real Blender 5.2.1 (a stored auto-run script does not run and
      does run with auto-exec on; an outside image renders nothing); Linux root
      spec 7/7 in a Node 20 container (uid, environ, cross-job read, RLIMIT_AS,
      11 of 12 processes, setsid sweep, hard link); output registry 151 with the
      dev MinIO accepting only the signed size and type and refusing moved,
      expired and old-style URLs; 3d-asset-library 144; tsc clean; eslint 0
      errors. Mutations of 14 guards each fail their spec. Not claimed: tools
      share the worker's network (a default container cannot create a network
      namespace); world-readable image and volume files stay readable;
      generation outputs under `jobs/` get no signed URL until T.04.05; nothing
      ran on RunPod. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.03.06
      and `docs/agents/evidence/isis-3d-studio/t0306/`._

## T.04 Canonical assets, editable scenes and lineage

Dependencies: T.03 shared contracts; existing output registry and storage.

- [x] **T.04.01** Implement a versioned asset manifest with actual artifact
      hashes, byte sizes, representation, units/axes, bounds, topology, material
      slots, UVs, rigs, clips, LODs, collisions and provenance. **Verify:**
      parsed fixture/live files agree with manifests; absent channels and
      inferred dimensions are explicit rather than invented defaults. _**Done
      2026-09-16.** `ThreeDArtifactManifestSchema` (`@isis/workflows`,
      `isis.3d-artifact-manifest` v1; named for artifacts because
      `ThreeDAssetManifest` is T.01.05's registry) records every item listed.
      Each section is `measured`, `absent` or `unmeasured` with a reason. Every
      material factor is `written` or `specification-default`. A real-world size
      is `unknown` unless declared, and declared sizes keep their basis (only
      `measured` is certifiable) and are compared per axis. Bounds place every
      vertex by node transforms, joints and default morph weights. `probeGlb`
      gained primitives, hierarchy, skins, clips, LODs, collision extensions and
      factors. `buildThreeDArtifactManifest` and `verifyThreeDArtifactManifest`
      (rebuild and diff by path) live in generation-api. The manifest is
      attached to the executor's `threeDPackage.manifest` (stage input hashes,
      RunPod job id, the request's dimensions) and to the Meshy lane's stored
      GLB, and published in the job schema, both OpenAPI documents (drift spec)
      and the client SDK (compile-time parity). **Found:** clip duration came
      from JSON `max` rather than keyframes (now keyframes, with a mismatch
      refused); Meshy rigging drops the normal and metallic-roughness maps (4
      images → 1, for T.11.01); the tool notices source count was stale; the
      client 4xx contract spec had failed since T.03.05 (responses now compose
      ErrorResponse). **Checks:** manifest spec 9 against glTF-Transform-written
      fixtures read back by glTF-Transform (4 mutations each fail); live spec on
      three Meshy GLBs from Hetzner, each verifying and agreeing with
      glTF-Transform; glb-probe 21, package 21, Meshy lane 48, job schema 36,
      OpenAPI 14, executor 3D spec extended (11 pre-existing failures
      unchanged), workflows 300, client 365; tsc known 8; parity mutation fails
      to compile; eslint 0 errors. Not claimed: registry records do not store
      the manifest yet (D5, P9 → T.04.02); only GLB is read; UV and mesh-defect
      quality belong to T.09; skinned bounds are the rest pose. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.01._
- [x] **T.04.02** Persist source/reference, generated, repaired and exported
      revisions with parent/dependency hashes. Preserve editable blend/CAD/
      procedural sources separately from GLB delivery. **Verify:** restore and
      branching reproduce accepted assets without rerunning generation; broken
      source dependencies prevent a false editable-source claim. _**Done
      2026-09-16.** The output registry gained `asset_revisions`, `asset_heads`
      and `asset_head_history` (`services/asset-revisions.ts`, routes under
      `/api/v1/assets`). A revision names its kind, the output holding its bytes
      and their SHA-256, its parent, dependency hashes, the T.04.01 manifest
      (refused unless it describes those bytes) and an editable source kept
      apart from the delivery. Its identity is a hash over those facts, so a
      repeat returns the first, concurrent repeats included; repaired and
      exported revisions need a parent. Accepting a revision moves head against
      the head the caller last saw (409 `revision_stale`), recorded as
      `accepted`, `branched` or `restored`. Restore works only for an accepted
      revision whose output is still stored with its hash, and creates nothing.
      Editable sources are resolved again on every read: a deleted, re-hashed or
      missing source file or dependency reads `broken` and `editable: false`. D5
      is fixed on the way: the registry now accepts generation-api's untextured
      or embedded-texture package and its manifest. **Checks:** live Postgres
      store spec 4 (restore after a branch returns the stored output with the
      output count unchanged; deleted, re-hashed and never-uploaded dependencies
      each break the source; mutations of the branch reason, deletion check,
      hash ordering and restore gate each fail); route spec 2 including the full
      flow over HTTP; registry suite 158/158 with Postgres and MinIO; tsc clean;
      eslint 0 errors. Not claimed: no job writes revisions yet (the
      job→registry producer is T.04.07); `.blend` dependencies are declared by
      the producer, not extracted; output deletion is not yet blocked for
      accepted revisions (T.04.05). Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.02._
- [x] **T.04.03** Add scene object IDs, instancing, hierarchy, transforms,
      cameras, lights and per-object asset revision references. Define canonical
      units/coordinate conversion. **Verify:** save/reload and import/export
      preserve IDs, instances and world transforms across nested hierarchies.
      _**Done 2026-09-16.** `@isis/3d-scene-assembly` gained the `isis.3d-scene`
      v1 document. Nodes carry stable ids, a parent and sibling order, TRS with
      a unit quaternion, and optionally an asset-revision instance (T.04.02), a
      glTF camera and a KHR_lights_punctual light. `validateThreeDScene` lists
      duplicate ids, missing parents, cycles, order conflicts, non-unit
      rotations, zero scales, impossible frusta and invalid lights;
      `worldMatrices` places nested nodes. Canonical space is glTF's (metres, +Y
      up, front +Z, right −X). `canonicalAxisConversion` states when a
      left-handed source is mirrored; its Blender, Unity and Unreal presets
      match their glTF exporters' mappings. `exportThreeDSceneToGltf` and
      `importThreeDSceneFromGltf` keep ids, order and instances in
      `extras.isis`, share one mesh per instanced revision, and read foreign
      files without inventing instances. **Found:** the old import normalizer
      returned an identity rotation for most axis pairs and sent a Z-up,
      Y-forward front to −Z (its spec asserted it); it now uses the conversion
      and requires handedness. **Checks:** lib 36 across 27 files. A binary glTF
      round trip of a nested room (instanced chairs, spot and point lights,
      camera) equals the original, with glTF-Transform's world matrices agreeing
      for every node. All 48 axis combinations compose correctly. Mutations of
      handedness and mesh sharing fail. tsc clean; eslint 0 errors. Not claimed:
      scenes are not yet stored as registry revisions; edit locks and undo are
      T.04.04; meshes are supplied by the caller. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.03._
- [x] **T.04.04** Implement object/region locks, optimistic revision checks,
      undo/redo and restore-as-new-head. User steering invalidates only affected
      pending stages. **Verify:** stale agent/manual edits cannot overwrite
      newer work; undo restores geometry, materials, camera and animation
      together. _**Done 2026-09-16.** Scene edits (transforms, instances,
      material overrides, cameras, lights, animation bindings, renames,
      reparenting, add and remove) land as one revision or not at all, each
      naming the revision it was made against. The output registry stores every
      revision's whole document under a head row locked FOR UPDATE, behind
      `/api/v1/scenes`. Object locks cover subtrees and region locks cover world
      origins before and after, as expiring leases held apart for a person and
      their agent (`X-Isis-Actor`). Undo, redo and restore write new revisions.
      Steering a running 3D job stores the changed request under its own
      revision and supersedes only runs whose dependency hash no longer matches:
      their jobs stop and they start new attempts that retry limits do not
      count, while everything else keeps its work. **Found:** a cancelled stage
      job's callback cancelled whatever attempt the run was on (after a
      queue-timeout retry it cancelled attempt 2); the cancel event now carries
      its job and attempt. A job created by a dispatch whose run had moved on is
      now stopped. **Checks:** on PostgreSQL, one of ten concurrent edits lands
      and nine are refused as stale; removing FOR UPDATE fails it 2/2. Over HTTP
      an agent lock blocks the person, the person's stale camera move is
      refused, and undo returns the exact earlier document. Steering the export
      while cleanup runs keeps cleanup's job; a size change supersedes geometry,
      cleanup and the running export and ignores its late callbacks. Making the
      superseded check ignore the hash fails both. Registry 58, generation-api
      3D 77, workflows 305, scene assembly 41 tests pass; OpenAPI and tool
      notices regenerated; no new tsc or eslint errors. Not claimed: no UI uses
      these yet; scene instances are not checked against the asset registry;
      steering cannot change which stages run. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.04._
- [x] **T.04.05** Extend uploads/downloads and retention to multipart meshes,
      textures, source bundles and clips, with tenant authorization, quotas,
      provenance and existing signing requirements. **Verify:** hash-verified
      retrieval and deletion/retention tests; shared blob reference counts keep
      accepted revisions alive without leaking another tenant's assets. _**Done
      2026-09-16.** The output registry gained packages: one output (mesh,
      texture set, source bundle or clip) whose parts are content-addressed
      blobs keyed by owner and hash. Parts upload through signed PUTs to staging
      keys; a commit hashes each staged object with the registry's credentials
      and copies exactly that version to the blob key, so wrong bytes are
      discarded and refused. Two packages of one owner share a blob; another
      owner naming the hash must upload it and can never read it. Quotas count
      stored blobs once plus pending uploads, keyed by the credential's tenant
      claim or the owner, and refuse loudly when unset. Downloads sign each part
      with its hash and size, and verify re-reads every part. Collection removes
      only blobs no live output uses, under row locks, and retention no longer
      expires outputs an accepted asset revision uses. **Checks:** on PostgreSQL
      and MinIO, every part downloads to its hash, substituted bytes are refused
      and removed, an overwritten blob fails verification, and another owner is
      refused at every step. Deleting and expiring packages removes exactly
      their own blobs while the shared and accepted ones stay and verify; the
      quota refuses with exact figures. Removing the hash check, owner filter,
      accepted-revision guard or live-reference check each fails its test.
      Registry suite 171 tests pass; tsc and eslint clean. Not claimed:
      single-file verify still fetches without credentials; parts over 5 GiB are
      refused rather than split; no job writes packages yet (T.04.07);
      collection runs on demand. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.05._
- [ ] **T.04.07** _(added 2026-09-16 from T.04.02; defect P9 in T.00.02)_ Record
      every finished 3D job in the output registry: register the stored mesh
      (and its sidecar textures) as outputs with the job's package and manifest,
      and create the job's `generated` or `exported` revision with its stage
      dependency hashes. Stage jobs share their parent's asset, and the terminal
      stage is the one accepted. Open question for the owner: how the generation
      API acts for the job's owner in the registry (a service credential per
      tenant, or registry tokens minted for the job's verified owner from a
      shared secret). **Verify:** a completed 3D job has a registry output and
      revision naming the same hashes; an unconfigured or unreachable registry
      leaves the job completed with a stated `outputRegistry` state rather than
      a silent gap.
- [x] **T.04.06** Support asset-library search, tags, thumbnails, variants and
      reusable collections with per-asset rights. Add viewer/editor/admin
      project roles through existing sharing primitives. **Verify:** selection,
      reuse, duplication and share revocation preserve lineage and
      authorization; library reuse never grants additional rights. _**Done
      2026-09-16.** No sharing primitive existed in Isis (records were
      owner-only; the asset library's community module has no access control),
      so viewer, editor and admin project roles are new registry tables, which
      the owner may want to revisit. Library entries index accepted asset heads
      with title, tags, rights, a thumbnail image, variants and duplication
      lineage, searchable by words and tags within what the caller may see.
      Collections show each reader only the items they could already see.
      Duplicates keep the source's owner, project and rights and record the
      source revision. Duplicates and variants need derivative rights. Editors
      may only narrow rights. Revocation ends access at once without losing
      lineage, and the last admin cannot leave. **Checks:** on PostgreSQL a
      viewer, an editor, the owner and a stranger each see exactly their share.
      A private asset in a project collection stays hidden. Closed rights block
      duplication even for the owner. A revoked editor's duplicate keeps its
      lineage while he loses access. Ignoring revocation, collection filtering,
      the rights-widening check or the derivative check each fails its test.
      Registry suite 179 tests pass; tsc and eslint clean. Not claimed: roles do
      not open byte downloads; thumbnails are linked, not rendered; scenes do
      not yet check library visibility; no UI. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.04.06._

## T.05 Neural geometry and text-to-3D vertical slice

Dependencies: T.01–T.04; baseline T.09 validation before delivery.

- [ ] **T.05.01** Implement a dedicated TRELLIS.2 adapter and native worker
      handler with versioned resolutions/controls, seed and real mesh/PBR
      output. **Verify:** pinned fixture/schema tests and one real asset per
      enabled profile, parsed GLB/materials and measured timing/cost; no legacy
      TRELLIS request schema is assumed compatible.
- [ ] **T.05.02** Add text -> concept image -> 3D using existing admitted
      Chroma/arsenal workflows, with reference/seed lineage and optional concept
      selection before geometry. **Verify:** prompt revisions invalidate the
      correct stages, material/shape references remain distinct and the final
      asset traces to the actual generated concept image.
- [ ] **T.05.03** Implement TripoSG as a separately advertised geometry profile
      and attach an admitted texture stage only when requested. **Verify:** real
      geometry and downstream textured exports; lower-memory claims match the
      measured worker profile and texture-free output is accurately labelled.
- [ ] **T.05.04** Implement Step1X geometry and texture as independently
      addressable stages after dependency clearance. **Verify:** real source
      mesh and generated texture artifacts, mesh preservation and actual channel
      inventory; bypass texture generation when native PBR is accepted.
- [ ] **T.05.05** Audit/upgrade original TRELLIS adapter for its actual
      available text/image/multi-image models. Evaluate it on the same reference
      corpus. **Verify:** pinned native requests run through the production
      worker; unsupported modes are unavailable and experimental conditioning is
      labelled.
- [x] **T.05.06** Add policy/resource/quality-aware fallback with explicit
      user-visible method changes and unchanged project constraints. **Verify:**
      unavailable model, OOM, failed quality gate and exhausted budget select
      only an admitted compatible backend or fail; a fallback never silently
      drops a view, texture requirement or topology constraint. _Done
      2026-09-18. A fallback is where quality systems go to die: the generator
      is unavailable or OOM or failed its gate or the budget is gone, the
      tempting move is to reach for whatever else is running, and what makes
      that fit is usually dropping the fourth view or the texture or the
      closed-manifold requirement — after which the pipeline reports success and
      nobody learns that what they asked for is not what they got. So
      CONSTRAINTS DO NOT MOVE: every candidate must satisfy all of them, one
      that does not is rejected with the reason, and if that leaves nothing the
      answer is a failure naming what eliminated the candidates. There is no
      field to return a relaxed constraint set in and `constraintsUnchanged` is
      a literal true because no path could make it false; the spec checks the
      constraints come back identical on a selection AND on a failure. Only
      admitted, deployed backends are eligible and admission is an INPUT, never
      inferred — an unadmitted backend at quality tier 9 and cost 1 loses to an
      admitted one at tier 1 with "a fallback does not route around admission".
      The four named failures are each tested: unavailable falls through with a
      method change naming both; OOM does not retry the failed backend and
      rejects a 40 GB one against 16 GB available; a failed quality gate
      excludes that backend and leaves the constraints (where a gate's
      requirements live) untouched; and an exhausted budget FAILS rather than
      taking something cheaper that does not fit — a 1-unit backend missing a
      required view beside a 50-unit one that fits, with 5 units left, gets a
      failure with both rejections spelled out. Among candidates that already
      fit the order is declared quality, then cost, then id, reproducible
      regardless of input order, and quality NEVER overrides a constraint (a
      tier-99 open-topology backend loses to a tier-1 closed one). The method
      change is a sentence and not a flag: "secondary will do this instead of
      primary, which stopped with out-of-memory (at 1024px). Everything asked
      for is unchanged: single-image, multi-view as conditioning, textured, PBR
      materials, manifold-closed topology, sfw_only."
      `describeLocal3DFallbackRelaxations` says what relaxing each constraint
      would buy and acts on none of it, ONE AT A TIME ON PURPOSE: where two
      constraints each block the same backend no single relaxation opens it and
      the function returns nothing, because "drop the texture requirement" would
      not in fact have helped — that case is its own test. **Checks:** 23 tests;
      `@isis/3d-generation` 78 passing across 13 files; tsc, eslint and the
      adversarial grep clean. Not claimed: this SELECTS and runs nothing — the
      adapters T.05.01–T.05.05 will build do not exist yet, so today the
      registry a caller passes is whatever is genuinely admitted and deployed,
      and with nothing admitted the policy correctly fails rather than inventing
      a route; the capability registry (quality tiers, VRAM peaks, costs) is
      declared by whoever registers a backend and T.17.02 owns measuring it; and
      relaxation is probed per constraint, not over combinations. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.05.06._

## T.06 Procedural geometry and exact CAD lane

Dependencies: T.02–T.04; director-assisted execution also requires T.08.

- [x] **T.06.01** Define component/assembly plans with dimensions, tolerances,
      symmetry, attachment relationships, materials and editable parameters.
      Classify measured versus inferred dimensions. **Verify:** constrained
      furniture, building and mechanical fixtures reject inconsistent units or
      impossible relationships and request missing essential measurements.
      _**Done 2026-09-16.** `@isis/3d-scene-assembly` gained the
      `isis.assembly-plan` v1 schema. Components carry dimensions, materials and
      ranged editable parameters. Attachments use the connector taxonomy's
      pairings plus rests-on, contains and fastened. Mirror and repeat symmetry
      and an envelope complete the plan, and every length carries unit, basis
      (measured, target or inferred) and tolerance. Validation converts to
      metres exactly and names the unit a slipped length would fit. It refuses
      rests-on loops, overfull stacks, measured parts that miss a measured
      envelope, asymmetric mirrors, openings and repeated holes outside their
      host, oversized tolerances and non-length units. It asks, as questions,
      for each class's essential measurements and for fit-critical lengths that
      were only inferred. Parameter edits stay in range and change one
      dimension. **Checks:** a measured chair, a wall with openings and a
      four-hole bracket are ready, and 20 targeted variants each fail or ask for
      the right reason. Removing the containment bound or the inferred-fit rule
      fails its test. Library 47 tests pass; tsc and eslint clean (one
      pre-existing spec-config error). Not claimed: no builder runs here
      (T.06.02, T.06.03); no general placement solver; ranges are sanity bounds,
      not standards. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.06.01._
- [x] **T.06.02** Execute versioned Blender Python builders for modular rooms,
      architecture, furniture, props and scene layouts in the DCC sandbox.
      **Verify:** deterministic parameter edits alter the intended component,
      preserve object names/relations and produce real blend/GLB artifacts.
      _**Done 2026-09-16.** `resolveAssemblyBuild` turns a ready assembly plan
      into an exact spec in metres (shapes, sizes, centres, turns, cuts,
      repeats). The versioned `isis.assembly-builder` 1.0.0 Blender script only
      instantiates it: named meshes with component extras, live boolean cuts,
      materials. The new `assembly-build` worker executor runs it sandboxed with
      auto-run disabled and fails any build whose report differs from the spec
      in version, plan hash, objects or cutters. **Found:** plan validation
      stacked by height alone, so floors given by thickness counted as zero; one
      vertical-extent rule now serves validation and building. The worker moved
      to the catalog's vitest 4, and its suite passes. **Checks:** with real
      Blender 5.2.1 a chair, a wall with openings, a furnished room and a
      drilled bracket each give a .blend and GLB. In every object the spec,
      Blender's measurement and the exported file agree to 1e-5 m. Rebuilding is
      byte-identical, and a table-top edit changes only the table top. A
      lopsided plan and an older builder version are refused with no output.
      Making the builder ignore rotation fails the room test. Tsc and eslint
      clean. Not claimed: no deployment runs assembly builds, the API does not
      dispatch them yet, only boxes, cylinders, quarter turns and simple cuts
      are built. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.06.02._
- [x] **T.06.03** Add CadQuery B-rep/STEP generation for exact solids, with
      parametric source preservation and validated tessellation for preview.
      **Verify:** volume, holes, dimensions, solid validity and Boolean results
      against analytical fixtures; mesh preview cannot substitute for CAD proof.
      _**Done 2026-09-17.** The `isis.cad-part` source (box or cylinder base,
      ranged parameters, holes, hole patterns, pockets, bosses) is validated
      against the cases where exact analysis would be wrong and resolved to
      millimetres with its exact volume, box and hole count. The versioned
      CadQuery 2.8.0 builder writes STEP, re-reads it and measures the B-rep
      (validity, solids, volume, optimal box, concave cylindrical faces). It
      reports a closed tessellated preview separately and keeps the source
      unchanged. The new `cad-build` executor fails any build whose B-rep does
      not certify; a preview alone is refused as proof. **Checks:** a drilled
      plate, a pocketed block with a blind hole and a bossed flange match their
      hand-derived volumes to 3e-14 or better, with exact boxes and hole counts.
      Their previews are off by 6e-6 to 4e-4, and substituting a preview volume
      does not certify. A parameter change rebuilds to its new answer. A kernel
      Boolean that splits a block yields two solids and fails. Counting convex
      faces as holes fails the flange tests. Library 55 tests; tsc and eslint
      clean. Not claimed: no image has CadQuery yet (T.02.01), the API does not
      dispatch CAD builds, no fillets, chamfers or sketches. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.06.03._
- [x] **T.06.04** Support OpenSCAD as an optional open parametric adapter where
      it provides a simpler constructive-solid workflow. **Verify:** pinned
      headless execution, parameter changes, reproducible mesh export and clear
      limits on conversions; do not promise a CAD feature tree from a mesh.
      _**Done 2026-09-17.** The `isis.openscad-part` source (program plus typed,
      ranged parameters) runs headless on the pinned OpenSCAD 2021.01 (release
      checksum verified; the executor refuses any other version). Parameters are
      passed as literal overrides, and programs that read files are refused.
      STEP, B-rep or feature-tree requests are refused with a pointer to the
      CadQuery lane, since a mesh cannot provide them. The executor measures the
      exported mesh itself and fails an open one. **Found:** OpenSCAD writes the
      same triangles in a run-dependent order, so the published STL is a
      canonical re-ordering with no vertex changed. **Checks:** the plate
      exports closed within 1e-6 of its exact polygonal-prism volume, and two
      runs give identical bytes. A parameter change exports its new exact
      volume. An open polyhedron OpenSCAD exports with exit 0 is refused.
      Publishing the raw STL fails the byte check. Library 59 and worker 84
      tests; tsc and eslint clean. Not claimed: no image ships OpenSCAD yet
      (T.02.01), the API does not dispatch it, only binary STL. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.06.04._
- [x] **T.06.05** Compose procedural assemblies with generated organic/detail
      parts using anchors, unit/axis conversion and material/part identity.
      **Verify:** hybrid vehicle/furniture examples retain interchangeable
      parts, dimensions and placement without destructive whole-object
      reconstruction. _**Done 2026-09-17.** Plan components with role detail are
      realised by GLB asset revisions. `resolveHybridAssemblyBuild` measures
      each asset from its bytes, checks its hash, and converts it from its
      authoring convention through canonical glTF to the builder frame. It then
      fits it (contain or native), anchors it on a procedural host face, and
      refuses collisions, sinking below the floor, overflowing the envelope and
      native size mismatches, leaving the procedural spec unchanged. Builder
      1.1.0 imports each asset once and instances it with its own materials, and
      the executor fails a build whose detail bounds differ from the resolved
      ones. **Found:** repeated imports duplicated materials; assets are now
      imported once. **Checks:** with real Blender a chair with a Z-up
      centimetre finial keeps all six procedural parts byte-identical to the
      plain chair, and the finial lands on the backrest top with its own
      material. A cart swapped from 16- to 24-sided wheels changes only the
      wheel meshes, in identical bounds, with the four wheels sharing one mesh.
      An unplaced detail is refused. Library 63 and worker 85 tests; tsc and
      eslint clean. Not claimed: the finial and wheels are authored stand-ins,
      not generated parts (T.05); collision is by boxes. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.06.05._
- [x] **T.06.06** Build CAD/architecture evaluation with known dimensions,
      counts, clearances, room openings and traversal/collision checks; use
      BenchCAD-style tests only in their valid scope. **Verify:** rendered
      similarity cannot pass dimensionally wrong or invalid solids; report
      structural/manufacturing uncertainty rather than engineering
      certification. _**Done 2026-09-17.** `evaluateAssemblyBuild` judges a
      build from the builder's own measurements against its resolved plan:
      dimensions within 1e-4 m, valid cuts (named boolean, vertex count), part
      counts, 3D clearances, collisions, opening clear sizes counted only when
      cut, and grid traversal with an agent radius through openings the build
      really cut. A rendered-similarity score is recorded but can never pass a
      failed check. BenchCAD-style checks run only for a CadQuery part, and the
      result says when they do not apply. Every result states what was not
      assessed and is never an engineering certification. **Found:** traversal
      carved openings the build never cut, and let an opening clear furniture
      standing in it; both fixed. **Checks:** a faithful room meets every check,
      and so does the real Blender room build. A 2 cm thicker table top with
      similarity 0.995 fails on dimensions. An uncut wall with similarity 0.999
      fails cut, opening and traversal. A moved table blocks the far-corner
      route. Strict counts, clearance, door width and wheelchair width fail for
      their own reasons. A 3-hole CadQuery plate with similarity 1 fails. Making
      similarity decisive, or carving uncut openings, fails the tests. Library
      67 and worker 86 tests; tsc and eslint clean. Not claimed: no structural,
      manufacturing or code assessment; no similarity metric computed; box-based
      spatial checks. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.06.06._

## T.07 Multi-view inputs and real-photo reconstruction

Dependencies: T.01–T.05; optional SAM access is an independent gate.

- [x] **T.07.01** Add ordered view sets with camera metadata when known,
      foreground masks, calibration/scale anchors and source provenance.
      **Verify:** duplicates, mixed objects, contradictory scale, wrong view
      labels and insufficient coverage return actionable errors; all supplied
      views remain traceable through inference. _**Done 2026-09-17.** The
      request contract already had ordered views with ids, roles, labels, masks
      and cameras, and refused duplicates, mixed objects and unordered
      reconstruction photos. It now adds view provenance and refuses a label its
      camera contradicts (naming the view the camera actually takes),
      reconstruction views that do not span 60 degrees, and scale anchors that
      disagree with each other or with the dimensions for the same axis. One
      rule decides which views each stage reads, shared with the dependency
      hash: every accepted request reports each view's stages (empty when
      nothing reads it), each stage job carries the views it consumed with their
      provenance, and the parent output lists them all. **Checks:** a front,
      three-quarter and left set with provenance is accepted and traced, while a
      mislabelled camera, an OpenCV misreading, a head-on three-quarter, a
      one-sided view set and contradictory anchors are each refused for their
      own reason. An orchestrated run records the front view in the geometry job
      and reports an unused style view. Flipping the camera convention fails
      four tests. OpenAPI and client types regenerated; stage suites 78,
      contract 52, workflows 308 tests pass. Not claimed: no inference consumes
      views yet (T.07.02 onward); label checks use direction only; provenance is
      not verified. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.07.01._
- [ ] **T.07.02** Implement genuinely joint multi-view conditioning where a
      model supports it, otherwise an explicit reconstruction/fusion workflow.
      **Verify:** held-out-view consistency improves over a single-view
      baseline; never concatenate inputs or ignore views and call that
      multi-view support.
- [ ] **T.07.03** Add admitted SAM 3D single/multi-object reconstruction with
      masks, shared pose/layout and separate object outputs. **Verify:** a real
      cluttered image produces independently editable objects with preserved
      relative placement; splats are not mislabeled as riggable triangle meshes.
      _2026-09-18, board tag: the three gated SAM 3D repositories still answered
      403 on 2026-09-15; access is the vendor's manual approval tracked in
      T.01.07._ `blocked:upstream`
- [ ] **T.07.04** Establish an open-profile photo alternative: user/admitted
      masks -> per-object generation -> constrained placement, plus an evaluated
      open multi-view photogrammetry path (candidate COLMAP/OpenMVS, license
      review first). **Verify:** calibrated multi-view recovery versus labelled
      single-image approximation; unsupported reconstruction remains an explicit
      gap.
- [x] **T.07.05** Track occluded/inferred surfaces, confidence, coverage and
      scale ambiguity. Offer additional-view input and preserve evidence when
      replacing speculative geometry. **Verify:** hidden-surface and mirrored/
      repeated-object fixtures cannot receive measured-fidelity certification.
      _Done 2026-09-18. A reconstruction from photographs is two things wearing
      one surface — the geometry the cameras saw and the geometry something
      guessed — and they render and export identically. A measurement taken off
      the second is a measurement of an assumption, usually "the back looks like
      the front", which is right often enough to be dangerous and wrong exactly
      when somebody relies on it. So the unit is the TRIANGLE and each carries
      how it came to exist: `observed`, `occluded`, `unobserved`,
      `inferred-by-symmetry`, `inferred-by-repetition`, of which only the first
      is a measurement. OCCLUSION IS TESTED BY RAY CAST, NOT BY NORMALS — a ray
      from each centroid towards each camera, intersected against the mesh's own
      triangles by Möller–Trumbore, because facing a camera and being visible to
      it are different claims. THE HIDDEN-SURFACE FIXTURE is a box inside a box:
      the inner box's twelve triangles all point outward and all face a camera,
      so a normals-only check calls the asset fully observed; the ray cast finds
      all twelve `occluded`, NOTHING `unobserved`, and the certificate is
      `partially-measured`. THE MIRRORED FIXTURE is refused EVEN WITH A CAMERA
      POINTING STRAIGHT AT IT, because what the camera would see is the mirror
      rather than the object — declared origin beats measured visibility, in
      that direction only — and a repeated instance observed once and copied is
      the same ("the copy was never looked at"); a wholly mirrored mesh falls to
      `inferred` at observed fraction 0. SCALE IS TRACKED SEPARATELY BECAUSE IT
      FAILS SEPARATELY: a box seen from all six sides with NO anchor has an
      observed fraction of 1.000 and is certified `inferred`, since the shape
      may be right and the size is not measured, and "measured" would be false
      in the one dimension somebody acts on. There is NO UPGRADE PATH
      (`canUpgradeInferredToMeasured` false) and
      `recordThreeDGeometryReplacement` THROWS when asked to record a region as
      having gone from `unobserved` to `observed` — "replacing a guess does not
      make it something that was seen" — while keeping what was replaced and
      why. A refusal comes with the photographs that would fix it:
      `recommendAdditionalViews` re-runs the observation with each candidate
      camera added and reports what it would ACTUALLY cover (four equatorial
      cameras leave the top and bottom unobserved; it names both and says each
      covers two triangles), and recommends NOTHING for mirrored geometry
      because no camera can un-mirror a mirror. **Checks:** 18 tests, passing
      first run. `@isis/workflows` is 1,465 passing, 1 skipped, 1 FAILING —
      `tool-admission.spec.ts > matches the generated notices document and SBOM     on disk`
      — which is PRE-EXISTING: stashing this item's three files reproduces the
      same single failure and it names no file of this item's. tsc and eslint
      clean (the redundant non-null assertions the neighbouring
      `request-contract.ts` carries were dropped rather than copied);
      adversarial grep clean. Not claimed: symmetry and repetition are DECLARED,
      not detected — a mirror leaves no trace in the geometry it produces, so
      whatever mirrored it has to say so, and guessing would be inferring that
      something was inferred; occlusion is against the object's own surface, not
      other objects or resolution limits; and the field-of-view test is a cone
      about the object's centre, a bound rather than a frustum, which would only
      ever narrow what counts as observed. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.07.05._
- [x] **T.07.06** Integrate existing segmentation/depth workflows as optional
      preprocessors with separate model families and clean transforms back to
      source images. **Verify:** crop/mask/depth alignment, alpha-edge handling
      and multi-object composition; a monocular depth estimate does not become
      an unqualified metric scale. _Done 2026-09-18. A preprocessor does not see
      the picture somebody uploaded: SAM 3.1 runs at source resolution, BiRefNet
      does its own preprocessing, and Depth Anything 3 sees a copy whose longest
      side was capped at 504 px (`DA3Inference`, `upper_bound_resize`, read from
      `zimage-txt2img-control.json` nodes 15–17). THE MAP IS CROP -> RESIZE ->
      PAD and padding has NO SOURCE PIXEL — `null`, because a letterbox bar read
      as content is how a mask acquires a rectangular border nobody drew. The
      identity checked is OUTPUT -> SOURCE -> OUTPUT, never the reverse: a
      downscale is many-to-one, so source -> output -> source cannot be an
      identity for a reason that is arithmetic rather than a defect. 1920x1080
      at the real 504 bound gives 504x284, round trip 0; 100x50 letterboxed into
      64x64 gives exactly 64x32 pad pixels, round trip 0; an aspect-changing
      resize is reported (a mask still maps back exactly, a depth field stops
      being a consistent depth field) and pixels outside the crop are ABSENT,
      NOT BACKGROUND. SEPARATE FAMILIES are `sam31`, `birefnet`,
      `controlnet-aux`: a preprocessor sharing the generator's family id is
      refused, because that is how a gated or excluded family rides into a job
      on an admitted one's admission. DEPTH IS REFUSED AS A STAGE ON PURPOSE —
      no standalone graph returns a depth map, the DA3 nodes exist only inside a
      generation workflow, and `no_standalone_workflow` names it rather than
      submitting a whole Z-Image render to get a map out of the side of it. A
      HARD MASK IS NOT A MATTE: one says which pixels belong to the object, the
      other how much of each pixel it covers, and blurring the first invents
      coverage nothing measured, so the conversion is REFUSED, not approximated
      — while the same mask as a selection is accepted. An unmatted edge pixel
      is an observed mixture `C = a*F + (1-a)*B_old`, so compositing it over a
      new background still carries `a*(1-a)*B_old`; that coefficient is summed
      as `edgeContamination`, largest at half coverage, so the halo is a number
      before the render. A CONTESTED PIXEL GOES TO NOBODY: overlap is settled by
      declared depth order and by nothing else, because picking the first or the
      largest mask is how an object silently loses an arm. ONE ANCHOR CANNOT
      SCALE A RELATIVE DEPTH MAP — `v2_style` normalisation leaves an unknown
      scale AND an unknown shift, two unknowns need two equations, and a
      one-anchor calibration is exact at the anchor and wrong at the far end
      where somebody measures the room; two good anchors solve `1/Z = a*d + b`
      and recover the planted a=0.5, b=0.1 to nine places, read through the
      transform, with basis `anchor` and the sentence "the depth map measured
      nothing; it propagated what the anchors measured". **Checks:** 35 tests,
      passing first run. `@isis/workflows` is 1,500 passing, 1 skipped, 1
      FAILING —
      `tool-admission.spec.ts > matches the generated notices document     and SBOM on disk`
      — the same PRE-EXISTING failure T.07.05 recorded, naming no file of this
      item's, and 1,500 is T.07.05's 1,465 plus this item's 35.
      `tsc -p tsconfig.lib.json` clean; eslint and prettier clean; adversarial
      grep clean. Not claimed: no preprocessor runs here (this is the contract,
      the transform and the arithmetic; the graphs are the existing catalog
      entries); the rasters are coverage arrays, not images, and no decoder is
      added; the alpha convention is DECLARED, since straight and premultiplied
      are indistinguishable from the alpha channel alone; and depth order is
      declared rather than read off the depth map, because wiring those two
      silently would make an unmeasured ordering look measured. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.07.06._

## T.08 Director, critic roles and bounded visual refinement

Dependencies: T.03–T.04 tools; consumes available lanes incrementally.

- [x] **T.08.01** Define provider-independent structured plans and role outputs
      for director, geometry/topology/material/rig/animation/engine critics and
      art direction. Include evidence IDs, severity, uncertainty and proposed
      operations. **Verify:** schema-invalid claims and ungrounded object/metric
      references are rejected; a role cannot mark its own unverified work
      accepted. _**Done 2026-09-17.** generation-api now has typed outputs for a
      director and seven critic roles, called through any provider behind the
      shared AI boundary. Critic findings carry severity, uncertainty with a
      measured, observed or inferred basis, evidence ids, object ids, restated
      metric values and typed operations named by object id, never by URL or
      command. Director plans carry steps with dependencies and acceptance by
      metric bounds, validators or a named critic, never the director itself.
      Output passes the shared structured-output check, a strict zod parse, then
      grounding against the control plane's objects, evidence and catalogues. It
      is refused for unknown ids, metrics or validators, a metric value that
      does not restate the measurement, a measured claim without a measurement,
      a stale revision, or an operation outside the role. An accept is refused
      over a failed hard gate, beside its own blocker, or on the role's own work
      without a passing validator or another role's review of that exact
      revision. **Checks:** 14 unit tests with the provider scripted at its
      interface cover each refusal, including a 0.52 m quote of a 0.644302 m
      seat rejected without a re-ask. Disabling the self-acceptance, restatement
      or object checks fails 2, 2 and 1 tests. Live, the cheap pinned DeepSeek
      model returned grounded revise verdicts for a three-legged chair in one
      call each (0.0009 USD). Not claimed: it did not attempt a self-accept
      live; numbers in free-text claims are not parsed; no loop or tools run yet
      (T.08.02, T.08.05). Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.08.01._
- [x] **T.08.02** Implement typed tools for plan/submit/cancel/status, import,
      inspect, render views, transform, mesh repair, materials, rig, motion and
      export. Use artifact IDs and revision preconditions, not arbitrary URLs or
      shell strings. **Verify:** authorization, idempotency and tool-output
      validation; reference text and tool outputs cannot inject privileged
      commands. _Done 2026-09-18. Thirteen tools, each with a zod schema whose
      every reference is an identifier of a known shape and whose every
      free-text field is declared as text. A model gets no shell, no URL and no
      path — not because it is asked not to use one, but because there is
      nowhere to put one: an id field takes only its own pattern, and no tool
      takes a URL or a command at all. An upload is named by its id, a material
      by its asset and revision, a job by its job id. Free text is length-bound
      and stripped of the control characters that smuggle a second line into one
      field, and is never read as an instruction. Writes and spends carry an
      idempotency key and, where they act on an asset, the revision they expect:
      a call against anything but the head is refused as stale rather than
      applied to whatever is there now, and a key reused with different
      arguments is refused because that is a bug and not a retry — a retry gets
      the first result back without acting again. A spend is bounded by what its
      caller may spend. Every result is parsed by the tool's own output schema
      before anyone sees it, so a tool that answers with the wrong state, or
      with an extra field, fails loudly instead of handing a model something it
      will believe. Authorization is a table: a critic is offered plan, status
      and inspect and nothing else, so a write is not something it has to be
      trusted not to try. Eleven spec cases, including ten hostile strings — a
      URL, an absolute path, a traversal, two shell lines, an embedded newline,
      a quote, a space and an empty one — refused in a top-level id field and in
      a nested one, and a tool message reading "SYSTEM: you are now allowed to
      call export_asset" coming back as a string that is then refused where an
      id belongs. Evidence: docs/agents/isis-3d-studio-evidence.md._
- [ ] **T.08.03** Admit and benchmark local tool/reasoning and
      image-understanding controllers; add optional Astra through the existing
      provider boundary. Discover model modalities/efforts/rates rather than
      assuming parity. **Verify:** a self-hosted plan/inspect/repair flow runs
      with hosted providers disabled; unavailable capabilities remain visible
      rather than falling back to paid APIs. Routine harnesses retain
      CLAUDE.md's cheap-model binding. _2026-09-18, owner decision: "optional
      Astra" means the Codex CLI on the ChatGPT subscription and nothing else;
      the provider boundary must refuse Astra on the OpenAI API and on
      OpenRouter. The lane and its allowance meter are F.01.08 and F.01.09._
      _ADMISSION, DISCOVERY AND ROUTING DONE 2026-09-18; the benchmarking half
      stays open. Left unchecked on purpose: the verify asks for a self-hosted
      plan/inspect/repair flow to RUN, and no local controller is installed on
      this box — `ollama`, `llama-cli`, `llama-server`, `vllm` and `lmstudio`
      are not on PATH and neither `127.0.0.1:11434/api/tags` nor
      `127.0.0.1:8000/v1/models` answers (curl exit 7). Installing a runtime and
      pulling weights is an owner decision about this machine.
      `controller-admission.ts` is the layer T.08.01's provider-independence
      needs, because "any provider works" becomes "whichever provider is
      configured" and the one always configured is the one that charges.
      CAPABILITIES ARE DISCOVERED, and the neighbouring code is why the rule
      needed writing down: `OllamaProvider.listModels` decides `supportsVision`
      from whether the model NAME contains "vision" or "llava", asserts
      `supportsTools: true` for models it has never met, and on a failed fetch
      returns a CHECKED-IN LIST instead of an error, so an absent server looks
      like a running one. Here a listing carries `reachable`, an unreported
      field stays `unreported` rather than becoming `false`, and a modality
      taken from an id is refused under its own code ("A name is not a
      capability"). DISCOVERED LIVE from `GET openrouter.ai/api/v1/models` (200,
      445 models, no key, no spend): the pinned harness model reports text,
      structured-output and tool-calling, 1,310,720 context and 0.06/0.12 USD
      per million — and reports that effort is STEERABLE WITHOUT NAMING THE
      LEVELS, so `effortControl` is true while `efforts` stays empty and
      unreported, since filling in a plausible low/medium/high is the assumed
      parity this item forbids. Its `input_modalities` is `["text"]`, so it is
      refused the image-understanding duty as a DISCOVERED FACT; the sibling
      vision row reports `["text","image"]` and is admitted. ASTRA: the live
      catalog lists `openai/gpt-6-astra` and three variants — the metered route
      is right there and would work — and admission refuses it on `openrouter`
      and `openai-api` BEFORE any call; a Codex child env carrying
      `CODEX_API_KEY` or `OPENAI_API_KEY` is refused (a key there moves Codex to
      API billing) while an empty value is not; a login not saying ChatGPT is
      refused, and this box's `codex login status` says "Logged in using
      ChatGPT". Astra is the only opt-in row and is never selected unnamed.
      HOSTED OFF MEANS HOSTED OFF: a duty nothing self-hosted reports comes back
      `unavailable` carrying the controllers that COULD have served it and why
      each was declined, the metered one by name with its billing — and the same
      need with hosted enabled does route to it, so the refusal is the profile's
      doing, not an incapacity. A `harness` duty is refused on `anthropic` and
      `openai-api` and on any model but the pinned dated snapshot, while keeping
      its critic and director duties. `compareThreeDControllers` counts only the
      tasks EVERY controller attempted and drops a controller benchmarked
      without a listing that said what it can do. **Checks:** 36 tests plus 2
      live; `@isis/workflows` 1,536 passing, 3 skipped, 1 FAILING —
      `tool-admission.spec.ts` notices/SBOM — the same PRE-EXISTING failure
      T.07.05 and T.07.06 recorded, and 1,536 is T.07.06's 1,500 plus 36. tsc,
      eslint, prettier and the adversarial grep clean. Not claimed: NOTHING
      ROUTES THROUGH THIS YET — no production code in the generation API
      constructs an `LLMProviderInterface` at all, so this is the policy its
      caller will use and that caller does not exist; no benchmark has been run
      by any controller; the local transports have never produced a real listing
      here, only the unreachable case; and the Codex CLI's effort levels have
      not been read into this shape. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.08.03._ _2026-09-18, owner
      instruction ("try to install what it needs"): **actionable, not parked.**
      The owner decision this note was waiting for is made: install a local
      controller. On the executing machine install `llama.cpp` (`llama-server`)
      or Ollama, pull one open-weights tool-calling model and one small vision
      model that fit the box's memory (record name, revision, quantization and
      licence in the controller register; ADR-0008 Q8, answered under T.00.06,
      says whether a quantized controller is acceptable — on a 15 GB CPU box
      nothing else fits), then run the self-hosted plan/inspect/repair flow with
      hosted providers disabled, which is the verify this item has been missing.
      Park only with a named failed install._
- [x] **T.08.04** Render fixed front/back/left/right/top/three-quarter views,
      silhouette, wireframe and material passes with calibrated cameras. Feed
      critic observations alongside computed geometry metrics. **Verify:** known
      missing-part/proportion/material defects are localized; critic confidence
      cannot override numerical or rights failures. _Done 2026-09-18. Six views
      and three passes, rendered by a versioned Blender script through Workbench
      so nothing depends on a light rig. The cameras are orthographic on
      purpose: every pixel of such an image looks along one line through the
      model, so the calibration that travels with the pictures turns a box of
      pixels back into the box of world space it could have come from — a bound
      across the view and the subject's whole depth along it, which is the
      honest answer from one view. Each camera is framed on the subject's own
      bounds rather than a sphere around them, and the frames are square so one
      half-extent calibrates both axes. The verdict is the other half: a failed
      measurement or rights check blocks, and a critic — at any confidence, in
      any number — can only raise a flag. Nine library specs and four with a
      real Blender: a figure of boxes with an arm out each side is rendered,
      then rendered again with one arm gone and framed identically; the two
      front silhouettes are differenced, and the changed pixels localize to a
      world box running from x 0.2 to past 0.7 at the arm's own height, which is
      where the arm was. The same difference, fed in as a measurement, blocks
      the review while a critic at 0.97 confidence says the figure looks
      complete. Found on the way: Workbench's own wireframe shading is a
      viewport mode and renders an empty image at every colour type, so the
      wireframe pass is made of geometry — a Wireframe modifier at a thickness
      calibrated to the view — and the spec now fails an empty pass rather than
      passing one. Evidence, with the four passes and the calibration:
      docs/agents/isis-3d-studio-evidence.md._
- [x] **T.08.05** Implement builder/critic repair loops with immutable
      candidates, ranked fixes, best-so-far preservation, maximum
      iterations/spend/time and deterministic stop/rollback criteria.
      **Verify:** no-improvement, oscillation, regression and impossible
      requests stop predictably; metrics and accepted regions remain attached to
      the exact tested revision. _Done 2026-09-18. A loop holds candidates, each
      immutable and each carrying the revision it was tested at, the checks it
      was tested with, and the regions accepted on it — so a metric and an
      acceptance belong to a revision and not to the loop. Recording a candidate
      changes nothing already in it: the new one is added, the best is kept
      unless this one beats it, and what this one was — better, worse, a repeat
      — comes back with the new state. The next fix is the lowest-ranked untried
      one that targets something still failing, ties broken on the id, so the
      same state always takes the same path. Eight ways to stop, each named with
      its number: accepted, when the best passes everything that decides;
      impossible, when nothing untried targets anything still failing; no
      improvement, after a run of iterations that did not move the score;
      oscillation, when a candidate fails exactly what an earlier one did;
      regression, after too many came back worse than the best; and out of
      iterations, out of money or out of time — the last two also refusing to
      start a fix whose own estimate would go past the budget. Acceptability is
      not the score: a candidate with a failed measurement or rights check is
      not acceptable however high it scores and however sure a critic is, which
      is the rule T.08.04's verdict applies, and a loop that wanders cannot lose
      what it had, because the best is never replaced by something worse and is
      what the loop hands back. Eleven spec cases, one for each ending and for
      the immutability, with the accepted regions of the candidate handed back
      being its own. Evidence: docs/agents/isis-3d-studio-evidence.md._
- [x] **T.08.06** Support asynchronous independent jobs, mid-run user steering,
      context retrieval/caching and effort escalation only for difficult
      decisions. **Verify:** stale results cannot overwrite steered plans,
      cancellations propagate, budget reservations cover parallel critics and
      cheaper/no-critic ablations expose actual quality/cost tradeoffs. _Done
      2026-09-18. Several jobs run at once and come back in whatever order they
      finish, while the person watching can change the plan at any moment; those
      two facts together are the problem. Every plan has a generation and every
      job carries the one it was launched for, so a result computed against the
      plan as it was is refused as stale, with both generations named, rather
      than merged into the plan as it is and quietly undoing the steering.
      Steering bumps the generation, marks what was running superseded and hands
      back their ids; cancelling the session hands back everything running and
      refuses to launch or steer again — so a cancellation reaches the jobs
      rather than only the session that owns them. Money is put aside for a
      purpose before anything is launched against it, and a fan-out of critics
      is bounded by the reservation it draws on, so the fifth of five is refused
      before it runs instead of being the one that discovers the budget is gone;
      a reservation settles on what a job really cost when its result arrives.
      Context is fetched once and cached with an age, and an entry past it is a
      miss rather than an answer that has changed underneath. Effort escalates
      only where a decision is hard by one of three stated measures — critics
      further apart than the policy allows, a measurement inside its own margin,
      or an attempt that already failed — and an escalation that names no reason
      cannot be recorded at all. And what the critics are worth is measured
      rather than assumed: runs with and without them are recorded, and the
      comparison reports the difference in quality and in cost, needs runs of
      both kinds before it will say anything, and declines to judge which is
      better because that depends on what a point of quality is worth. Eleven
      spec cases. Evidence: docs/agents/isis-3d-studio-evidence.md._

## T.09 Mesh cleanup, topology, UVs, LOD and collision

Dependencies: T.04 and any real mesh producer; baseline checks gate M1.

- [x] **T.09.01** Parse real meshes and measure degeneracy, nonfinite vertices,
      disconnected components, intersections, winding/normals, open boundaries,
      density and scale. **Verify:** deliberately corrupt fixtures fail for the
      correct reason; intentional sheets/leaves/clothes pass their applicable
      open-surface profile without forced watertight repair. _**Done
      2026-09-17.** The GLB reader now returns the placed triangles of a scene
      (node transforms, rest-pose skinning, strips and fans, mirrored instances
      re-wound, normals turned and kept at their file length), and the
      post-pipeline library measures them: non-finite vertices and normals,
      degenerate triangles, open boundaries, non-manifold and reversed edges,
      orientation by nesting depth so cavities pass, normals against winding,
      self-intersections, isolated fragments by surface contact, density and
      scale with suggested units. A closed-solid profile blocks on all of them;
      an open-surface profile only reports open boundaries and repairs nothing.
      **Checks:** 16 library and 3 GLB tests. Each corrupt fixture fails for
      exactly its own reason, while a sheet, a leaf and cloth pass open-surface.
      On three real Meshy meshes (31 thousand to 753 thousand triangles, up to
      10 s) trimesh reproduces every topology count and the area. Blender finds
      a subset of the intersecting pairs, and exact arithmetic shows each extra
      pair truly crosses. Three mutations each fail. Not claimed: no stage or
      certification consumes the verdicts yet (T.09.06); nothing is repaired
      (T.09.02); compressed or sparse geometry is refused; skins are measured in
      rest pose. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.09.01._
- [x] **T.09.02** Implement configurable Blender/CuMesh cleanup, floater
      removal, decimation and normal repair with preservation masks and source
      retention. **Verify:** silhouettes, thin parts, part count and material
      groups meet declared tolerances; cleanup cannot silently delete semantic
      components. _**Done 2026-09-17** (Blender only; CuMesh is not admitted). A
      gpu-worker job runs a versioned Blender script that merges vertices,
      dissolves degenerates, removes floaters, fills holes, recalculates normals
      and decimates, skipping preserved objects and islands with preserved
      materials and reporting every removed or kept island. The source is
      retained byte for byte. The job then reads both files independently, with
      rest-pose skinning, and fails unless part names, axis silhouettes,
      material areas, thin-part bounds and surface deviation meet the request's
      tolerances, and every vanished island matches a declared, unpreserved
      removal. **Checks:** 6 verifier tests catch undeclared, preserved and
      thin-part removals, shrinkage and renames. Three real Blender 5.2.1 runs
      clean a test chair within tolerance (debris removed, button kept,
      inside-out cushion fixed), reject a destructive request and respect a
      preserved object. Three real Meshy meshes, including a rigged one and a
      753 thousand triangle scan, halve their triangles within tolerance. Three
      mutations each fail. Not claimed: an enclosed cavity counts as a floater
      (reported); hole filling is not exercised; no asset revision is written.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.09.02._
- [x] **T.09.03** Add Blender/QuadriFlow remeshing plus a distinct deformation
      topology track for faces, shoulders, elbows, knees, hands and cloth.
      **Verify:** edge-flow/deformation examples, artist review and before/after
      measurements; label algorithmic remesh separately from artist-quality
      retopology, with a manual correction/reimport path for unresolved cases.
      _Done 2026-09-18. A gpu-worker mesh-remesh job runs a versioned Blender
      script that puts QuadriFlow over a mesh with its own controls — a target
      face count, preserve sharp, preserve boundary, use symmetry, a seed — and
      writes the result as an OBJ, because glTF triangulates and the quads are
      the point. The deformation track is separate and is a measurement, not a
      second remesher: a named region is a sphere at a joint with the limb's
      axis, and what is measured in it is how much of it is quads, how many of
      its vertices are not four-valent, how evenly its edges are sized, and how
      many loops run round the limb — counted as clusters of edges within thirty
      degrees of perpendicular to the axis, sharing a position along it to
      within half the mean edge length. Each kind of region has a stated
      profile, argued in the code rather than asserted: a knee with two loops
      pinches, and a face needs loops round the eyes and the mouth before
      anything else. A region that meets its profile is reported as meeting it;
      one that does not is reported with what it is short of and handed to a
      person, and the two can never disagree because the request is derived from
      the measurement. The labels cannot be confused: everything the remesher
      produces is algorithmic-remesh, and artist-retopology takes a named
      reviewer and a reimport that was measured first — every vertex of the
      returned mesh within tolerance of the original's surface, its size
      unchanged, and the regions it was sent away for now meeting their
      profiles. Eight library specs and three with a real Blender: a bent tube
      of 1,152 triangles becomes 526 faces, all of them quads and no n-gons,
      staying within 10 mm of the surface it came from and 2 mm on average; the
      elbow region measures 210 faces, no poles, 23 loops across and 9% edge
      variation, which meets an elbow's profile, so nothing is sent to anyone —
      while the library's sparse limb falls two loops short and is. Evidence,
      with the measurement and the remeshed OBJ:
      docs/agents/isis-3d-studio-evidence.md._
- [x] **T.09.04** Implement xatlas/Blender UV workflows with island padding,
      seams, distortion, texel density, overlap policy and material
      preservation. Support UDIM only in profiles that can export/re-import it.
      **Verify:** known seams/stretch/overlap fixtures and rebaked textures;
      existing valid UVs survive unless replacement was requested. _**Done
      2026-09-17** (xatlas only, no Blender UV path). UV layouts are measured
      for islands, seams, stretch as anisotropy and area distortion, texel
      density, raster overlap with a fill rule, padding in pixels and UDIM
      tiles. They are validated against a glTF profile that forbids overlap and
      has no UDIM, so tiles are refused there and recorded where a profile
      supports them. Unwrapping with the admitted xatlasjs 0.2.0 fills missing,
      invalid or all layouts per material atlas, fitted to one page at the exact
      resolution. It rebakes every non-normal texture onto the new layout, keeps
      material names and factors, and keeps valid UVs byte for byte unless
      replacement is requested. It refuses normal-mapped materials, unbakeable
      or shared cases, and oversized meshes with reasons. **Checks:** 8 tests
      with exact seams, stretch 4, overlap 0.2, UDIM and padding fixtures. A
      rebake matches the old texture within 0.13 of 255 at matched points while
      a clean mesh stays identical. Three mutations each fail. A real Meshy
      layout is measured, correctly refused for its normal map, and, with the
      map removed, re-unwrapped to anisotropy 1.20 and 9 px padding with a
      reported 0.01 percent overlap. Not claimed: no normal-map rebake, UDIM
      delivery, or meshes over 65,535 vertices. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.09.04._
- [x] **T.09.05** Generate target-specific LOD chains, collision meshes and
      optimization/compression using admitted tools including meshoptimizer.
      **Verify:** actual polygon/draw-call/texture-memory reductions, silhouette
      error bounds, skin/animation preservation and valid runtime switching;
      compression is never presented as model-weight quantization. _**Done
      2026-09-17.** Versioned web-mobile and engine LOD profiles drive level
      chains built with the admitted meshoptimizer 0.18.1 (weld, simplify,
      dedup, primitive join, prune keeping solid textures, texture caps with
      sharp). Each written level is measured for triangles, draw calls, texture
      memory, bytes, axis silhouettes against level 0, material texture slots,
      skins and animations, with switch distances from screen coverage. Convex
      collision hulls per part must contain every source vertex. Compression is
      labelled as geometry and animation quantization for delivery, never
      model-weight quantization, and each compressed level is decoded and
      compared again. **Checks:** 4 tests on a skinned, animated, textured
      fixture pass every check with exact texture memory, joined draw calls and
      preserved rig, and a three.js LOD switches levels at the derived
      distances. A too-harsh level fails its silhouette and target checks. Three
      mutations each fail. A 753 thousand triangle scan passes with IoU at least
      0.997 and meshopt bytes 2.3 to 0.25 MB. Two seam-heavy meshes honestly
      fail their deep reduction targets. Not claimed: no engine frame-time
      profiling (T.16.03), convex hulls only. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.09.05._
- [x] **T.09.06** Version quality profiles for rigid, deforming, architectural,
      web/mobile, engine and print targets. Record thresholds with units and
      evidence, not a universal green score. **Verify:** failing any required
      validator blocks that target's ready label; changing a profile invalidates
      stale certification without deleting source artifacts. _**Done
      2026-09-17.** Version 1 profiles for all six targets list validators over
      the T.09.01 measurements, each with a threshold in its metric's unit,
      whether it is required, and evidence: quoted clauses of glTF 2.0 and 3MF
      Core section 4.1 checked against the sources, or a named Isis decision
      with its reason (budgets and the print volume are initial decisions).
      There is no score. A certificate records the profile hash, the measured
      bytes and a pass, fail or unmeasured result per validator, and is ready
      only when no required validator failed or went unmeasured. The
      output-registry computes certificates itself, binds them to the revision's
      content hash, and labels each target ready, blocked (naming validators),
      stale or uncertified. Invalidation marks superseded certificates and
      deletes nothing. **Checks:** 5 profile tests and 3 store tests on real
      PostgreSQL. An open sheet is blocked for print by watertight while ready
      for web-mobile, and an unmeasured skin blocks deforming. A second
      web-mobile version turns the label stale; marking leaves output, revision
      and certificate counts unchanged, and re-certifying blocks on the tighter
      budget. Three real Meshy meshes are labelled per target. Three mutations
      each fail. Not claimed: no route or deploy hook yet; facts are trusted
      from the measuring service; deformation, UV, material and LOD validators
      come later. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.09.06._

## T.10 PBR generation, retexturing and material QA

Dependencies: T.01 texture admission, T.04 assets, T.09 UV/baking contracts.

- [x] **T.10.01** Normalize actual base-color, metallic, roughness, opacity,
      normal and optional AO/emissive channels with color-space, packing,
      tangent and normal-Y conventions. **Verify:** missing or constant default
      maps are accurately described; known material fixtures render correctly in
      Blender and the glTF viewer without baked-lighting substitutions. _Done
      2026-09-18. glTF fixes the conventions — base colour and emissive sRGB and
      everything else linear, occlusion, roughness and metallic sharing one
      texture in that order, a tangent-space normal map with its green channel
      up — and a material is now described against them, channel by channel,
      including the ones that are not there. That last part is the item's point:
      a channel with no texture is not black, it is the factor, and the report
      says so with the factor's value; a channel whose texture carries one value
      everywhere is a factor with a file around it, and the report says that
      with the value, the size and whether it agrees with the factor it would be
      replaced by. A flat normal map is named for what it is rather than counted
      as detail, and a normal map's own scale is never compared with its pixels,
      because a scale on a direction is not a value a map stands in for. What
      cannot be read off the pixels is refused rather than guessed: no
      measurement tells OpenGL's green channel from DirectX's, so an undeclared
      convention is a finding and a declared DirectX one plans the flip. A
      component of a shared texture that varies and that nothing reads is
      reported, and so is a colour space that is not the one glTF asks for.
      Conventionality is scoped to the conventions: a material of constant maps
      is conventional and wasteful, and those are two different findings. Seven
      spec cases, three of them against Blender's own glTF importer — the thing
      that implements the specification — on a file built with a varying base
      colour, an occlusion-roughness-metallic map whose red is constant, whose
      green is a gradient and whose blue is zero, and a flat normal: the base
      colour arrives on Base Color in sRGB, metallic and roughness arrive from
      the blue and green of one Non-Color image through a separator, the normal
      arrives through a Normal Map node, and nothing lights itself. Evidence:
      docs/agents/isis-3d-studio-evidence.md._
- [ ] **T.10.02** Implement mesh + text/image -> texture workflows for admitted
      Step1X/Paint3D/TEXGen or supported TRELLIS.2 texturing. Explicitly
      distinguish direct controls from concept-image conditioning. **Verify:**
      prompt/image influence, texture resolution, mesh/UV preservation and real
      emitted channels on existing user meshes. _Blocked 2026-09-18: no
      texturing model is admitted. The registry's C4 rung still lists TRELLIS.2
      texturing, Paint3D, TEXGen and the Step1X texture stage as candidates, and
      its unpromoted evidence records that the texturing library has no runtime
      importer. This needs T.10.07 or a Step1X/TRELLIS.2 texture admission
      first; the rest of T.10 (01, 03–06) is done and does not wait on it._
      _2026-09-18, board tag: waits on T.10.07 or another texture admission, as
      the note above says._ `blocked:upstream`
- [x] **T.10.03** Support per-material/per-region retexturing with locked
      geometry, selected slots and unchanged areas. **Verify:** only selected
      material assignments/maps change; before/after hashes and view comparisons
      expose unintended changes to accepted parts. _Done 2026-09-18. A retexture
      is trusted for what it did not touch, so the selection is measured before
      anything is painted. Materials are shared between primitives and images
      between materials, and each such reach is a collision with a named
      resolution — fork the material, fork the image — that a plan must take or
      be refused; a region's reach is measured in texels, its UV triangles
      rasterised into the texture's own grid by separating axis and dilated by
      the padding the write bleeds, against the same for the faces around it, so
      the contested texels are counted rather than hoped away. Afterwards two
      snapshots are differenced — per-accessor geometry hashes, per-channel
      bindings, per-image content hashes — and every difference classified
      against what the plan promised. Geometry is never an intended change, and
      a promised change that did not happen is its own verdict, because a
      retexture that quietly did nothing passes every "nothing else changed"
      check there is. Hashes cannot see a material that moved because another
      material's image moved under it, so the same cameras are rendered before
      and after and compared per material region against a control: a second
      render of the unchanged file, whose difference is the renderer's own
      noise. Nothing here generates a texture; the pixels are the caller's.
      **Checks:** 21 tests, 5 of them driving Blender 5.2.1 over four real glb
      files built from two panels, two materials and one shared base-colour
      image. Cycles on CPU at a fixed seed rendered the same file to identical
      bytes, so the floor is zero; the forked retexture changed 2,450 of the
      left panel's 2,450 front pixels by up to 139 and left the right panel's
      2,450 at a maximum difference of 0, and the careless edit that rewrote the
      shared image in place moved the locked panel by the same 139 — caught by
      the hashes as an unintended `image-bytes` change with both promised
      changes missing, and by the views as `locked-region-changed`. A moved
      vertex fails the lock although the retexture itself was right. Not
      claimed: no texture is generated, the mask pass is per material and not
      per texel, and the plan's operations are carried out by the caller's tool.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.10.03._
- [x] **T.10.04** Bake high-to-low normal/AO/material data with cage/ray
      controls, seam padding and deterministic channel packing. **Verify:**
      normal direction, projection misses, seams and shading match reference
      geometry; baker failure cannot produce a claimed complete PBR bundle.
      _Done 2026-09-18. A baker is a projector, and the three things that go
      wrong with one are measured rather than assumed. Rays that hit nothing:
      each map is generated black and baked with clearing off, so a texel no ray
      reached keeps its black — and for a tangent-space normal map black is a
      value no answer can take, since the blue of a unit normal in the upper
      hemisphere is never below 128, which makes the misses countable and makes
      them the misses of every channel baked through the same cage. Occlusion
      and roughness are not counted that way, because black is a legitimate
      answer there. Padding that does not reach: how far past the low mesh's own
      UV coverage a written texel is found, measured, against the margin that
      was asked for. A normal map that means something else: nothing in the
      pixels says which way is up, so the map is shaded onto the low mesh and
      compared with the high mesh under two lights, then compared again with its
      green channel flipped — and agreeing equally well is reported as proving
      nothing rather than as a pass. Requests that cannot come out right are
      refused before the rays are spent: overlapping UVs, a margin wider than
      the gap between islands, a ray distance shorter than the extrusion it
      starts from. A bundle is complete only when every claimed channel has a
      source that was produced, the misses are under policy, the normals are
      unit vectors pointing out of the surface and the packing judgement is
      silent. **Checks:** 33 tests, 9 of them driving Blender 5.2.1 over a
      paraboloid dome 0.12 high baked onto the flat square under it. The good
      bake missed 0 of 10,816 covered texels and padded 1,244 outside them; its
      normals reach a maximum tilt of 25.22 degrees against the dome's analytic
      rim slope of 25.64. A ray distance of 0.15 from an extrusion of 0.2 loses
      the rim — 47.1% missed; a cage object starting at 0.05, below the dome's
      peak, loses the middle instead — 36.5% missed, the centre texel black. A
      margin of zero pads nothing and leaves 412 edge texels unwritten. Both
      failures certify as refused. Occlusion, roughness and a metallic constant
      pack into one texture in glTF's order, byte-identical on a second packing,
      and a swap of two components is caught by comparing each packed
      component's range and mean with its source's. Shading: the baked map
      differs from the high mesh by a mean of 0.66 and 0.76 of 255 over 11,236
      pixels under two lights, and its flip by 19.71 and 21.84 — confirmed. Not
      claimed: one baker (Blender's), one fixture shape, and the packer itself
      is the caller's. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.10.04._
- [x] **T.10.05** Add material QA under several known lighting environments for
      seams, baked illumination, implausible roughness/metallic, opacity and
      reference consistency. **Verify:** numeric channel checks plus rendered
      defect fixtures and critic evidence; quality improvement cannot rely on
      one favorable camera/light configuration. _Done 2026-09-18. A seam is not
      a look, it is a place: an edge two triangles share in space and do not
      share in UV space. Those edges are found from the mesh and the texture is
      sampled on both sides of every one of them, stepped perpendicular to the
      edge so the two samples stay at the same point on the surface and only
      move into their own island — stepping towards the triangle's third corner
      instead reads two different places and invents a seam out of a texture
      that has none, which is how the first version of this failed. Baked
      illumination is found by fitting the base colour's luminance against a
      Lambertian term over the surface's own normals, searched across a lattice
      of directions: a high correlation means the map knows which way the
      surface faces, which albedo does not. Roughness, metalness and alpha are
      read against the ranges the model admits. Everything that depends on a
      render is run under every declared environment and the verdict takes the
      worst; an improvement counts only when it holds under all of them.
      **Checks:** 25 tests, 6 driving Blender 5.2.1. The fixture is a dome cut
      into two UV islands, with 24 seam edges found and every one of them on the
      plane the cut was made along. A texture that does not vary across the cut
      measures a seam of exactly 0 and one with an island offset measures 60 on
      every sample. The illumination fit recovers a baked light's direction to
      within a dot product of 0.9 at a correlation above 0.95, leaves a striped
      map at under 0.7, and refuses to answer on a flat plane. The same normal-
      map discontinuity renders at 65.3, 12.0 and 7.1 bytes of step under a
      grazing sun, a head-on sun and a uniform world, against 5.3, 0.1 and 1.3
      for the material without it. That last number is the honest one: the tidy
      physics says a uniform world should hide the seam, and it does not — the
      diffuse term does not know the normal but the specular lobe's Fresnel term
      does — so the result is a factor of nine and a visibility bar anywhere
      between them passes the same material under one environment and fails it
      under another. One landmine fixed along the way: a world's `color` never
      reaches Cycles, which renders the world's node tree, so three declared
      environments had all been rendering under Blender's own grey; the
      background pixel is now the check that the declared colour took. Not
      claimed: no HDRI environments, one camera, and the reference-consistency
      check reports that no reference was given rather than passing for want of
      one. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.10.05._
- [x] **T.10.06** Expose texture presets and bounded 1K/2K/4K tiers only where
      measured, with supported UDIM/tileable-material options. Preserve reusable
      material libraries and attribution. **Verify:** byte/memory estimates,
      downsampled/packed exports and capability limits; no generated upscaler
      detail is represented as recovered source detail. _Done 2026-09-18. A tier
      is a claim about detail, not about pixels, so the detail is measured: the
      map is reduced to a candidate tier and brought back by a named filter, and
      a map that returns within the floor never held anything above that size. A
      tier above the measurement is refused with the measurement quoted. The
      limit of that is declared rather than papered over — a resampling upscale
      invents nothing a smaller version cannot reproduce and the round trip
      finds it, but a generative upscaler's invention is real high-frequency
      information that survives any round trip, so no measurement of the pixels
      can tell it from captured detail. The source size and the provenance are
      therefore declared, and a tier whose detail was declared generated is
      offered as generated and refused as source. Cost is two numbers because it
      is two things: the file's bytes, which only the caller has, and the
      card's, which is a calculation — and three-channel colour is charged as
      four, because that is what the card stores. Tiling is measured on the
      edges that have to meet; UDIM tiles are read off the UVs with the
      triangles that straddle a boundary counted rather than assigned. A library
      entry whose licence asks for a name and has none is refused, not exported
      blank. **Checks:** 15 tests. Two 2048 value-noise maps that no header
      tells apart: one with a lattice at 512 cells returns from 1024 with an
      RMSE of 12.3, and one drawn at 1024 and resampled up returns at 1.6 —
      below the floor of 3, which is not zero because a reduction and a return
      through a windowed sinc and eight bits is not the identity. The first
      offers 1024 and 2048 and refuses 4096 as above the stored size; the second
      offers only 1024 and its refusal quotes the measurement. The same map
      declared as a generative upscale from 1024 offers 2048 labelled generated
      and refuses to call it source. A real downsampled export replaces a 2048
      map with its 1024 reduction: the file shrinks, the card's cost is exactly
      a quarter, and the T.10.03 judgement confirms the geometry and everything
      else is untouched. That export also found a T.10.03 rule that was too
      broad — a whole-slot resize was refused as if it moved the UVs, which it
      does not, since UVs are normalised — and it was narrowed to region
      selections, where the texel count really does belong to the old grid. Not
      claimed: no BCn encoder runs, one resampling filter, and tileability says
      the edges meet and nothing about whether the repeat is visible. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.10.06._
- [ ] **T.10.07** _(added 2026-09-14 from T.01.02)_ Complete Paint3D admission:
      read the UV-position and tile ControlNet dtypes on a download host,
      re-host them as safetensors, run its second stage on the cleared SD 1.5
      base instead of Realistic Vision, pin every dependency and re-run the
      admission check, then continue with T.10.02. **Verify:** Paint3D admission
      passes every rule; PBR channels beyond albedo still route to
      T.10.01/T.10.04. _Blocked 2026-09-18 on this Mac: the item needs a
      download host to read the ControlNet dtypes and re-host them, and to run
      the second stage on SD 1.5. The Linux dev server is not reachable from
      this session — `ssh dev-server` does not resolve and `~/.ssh/config` has
      no entry for it — and this machine is not a download host for
      multi-gigabyte weights. Resume from the Linux box or a RunPod loader pod._
      _2026-09-18, correction from a session ON the Linux dev server: the
      blocker above is a fact about the Mac, not about this item. From here the
      ControlNet headers can be read and the weights re-hosted as safetensors on
      CPU (check `df -h /mnt/volume300` first); only the second stage on SD 1.5
      needs a GPU, which is a RunPod loader pod and the usual
      ask-before-spending. Left untagged on purpose: this is actionable._
- [ ] **T.10.08** _(added 2026-09-14 from T.01.02)_ TEXGen stays out until a
      code licence exists. If one is published: replace nvdiffrast (T.01.06),
      resolve the stable-diffusion-2-depth text encoder that answers HTTP 401,
      and re-run the admission check. **Verify:** the candidate's outcome in the
      manifest changes only on a recorded licence and a passing check. _Blocked
      2026-09-18: no code licence has been published for TEXGen, and asking its
      authors for one is an owner decision already recorded in T.01.07. Nothing
      here is actionable until that answer exists._ _2026-09-18, board tag:
      TEXGen has published no code licence._ `blocked:external`

## T.11 Rigging, skin transfer and deformation validation

Dependencies: T.01 SkinTokens admission, T.04/T.09 validated assets.

- [ ] **T.11.01** Integrate TokenRig/SkinTokens skeleton+weight inference and
      existing-skeleton skinning with pinned settings, original scale and
      texture transfer. **Verify:** real rigged GLB, valid hierarchy/inverse
      bind matrices, finite normalized influences and preservation of input
      materials/units.
- [x] **T.11.02** Classify rig needs by anatomy and intended motion: humanoid,
      quadruped, winged/multi-limbed, mechanical/articulated prop or rigid.
      **Verify:** representative anatomies and unsupported cases; rigid assets
      bypass rigging and humanoid motion is never blindly applied to creatures.
      _Done 2026-09-18. A wrong answer here is worse than no answer — a humanoid
      walk on a bird bends wings like arms — so the classifier measures, and
      where the measurement does not decide it says so and names what it was
      torn between. The measurement is protrusions: Dijkstra over the surface
      from the middle of the shape gives every vertex its distance along the
      surface, and the local maxima of that field are the ends of the shape's
      limbs. The middle is found the way a tree's centre is, by walking to the
      furthest point, walking to the furthest point from there and halving that
      path — starting from the vertex nearest the centroid puts the origin on a
      leg whenever the centroid falls in the space between the legs, and the
      legs then measure as short and the shape loses them. Not every maximum is
      a limb: a cube has eight, because its corners are maxima of the surface
      distance exactly as a fingertip is, so a protrusion counts only if its end
      is long compared with how thick it is. Each limb's direction is the long
      axis of its own end, by power iteration on the covariance of the last
      quarter of its reach; the offset from the centroid would call a
      quadruped's leg diagonal, because the foot is as far along the animal as
      it is below it. The rules are then conditions on measured numbers, each
      reported with the number behind it. Intent is used in exactly two places:
      it decides between candidates the shape could not separate, and it turns
      anything into rigid when nothing is going to move it. An intent that
      disagrees with a shape that did decide is a finding and does not override
      it. The guard refuses a clip authored for another anatomy, and refuses one
      on a rig whose anatomy is undecided, because the point of `undetermined`
      is that nothing downstream may act as though it were decided. **Checks:**
      18 tests over figures built from lattice cells — a surface welded from the
      faces no neighbouring cell covers, so each figure's anatomy is readable
      off its cell list. A standing biped: 5 protrusions, 2 pointing down,
      upright 2.29, reach spread 1.24, symmetry 0.94 → humanoid. The same biped
      with its arms lengthened: spread 1.36 and 1.41, both the humanoid and
      winged rules hold → undetermined, and an intent to fly or to walk settles
      it. Longer still: as wide as it is tall, no rule fits → unsupported. A
      four-legged body: 4 down, upright 0.44 → quadruped. Six legs →
      multi-limbed; a 20-cell tube → serpentine; two loose blocks → articulated
      prop; a solid block → no protrusions at all → rigid, bypassing the rigger.
      A humanoid clip on the winged reading is refused with "bend wings like
      arms"; any clip on a rigid or undecided asset is refused. Not claimed: no
      head detection — a head is short, its end runs into the shoulders before
      its own axis is clear, and the rules are built not to lean on it; the
      thresholds were set against these figures and not against scanned meshes;
      and glTF fixes up but not forward, so which horizontal direction is
      sideways has to be declared — the same animal modelled along X reads its
      head and tail as lateral until it is told which way it faces. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.11.02._
- [x] **T.11.03** Add skeleton mapping, joint axes/limits, rest-pose conversion,
      bone naming and influence budgets for browser/engine profiles. **Verify:**
      round-trip skeletons, nonuniform scale and mirrored limbs; mapping keeps
      root motion and orientation consistent across target conventions. _Done
      2026-09-18. Everything is derived from one declaration per target — where
      its own right, up and forward point, how many metres a unit is, how many
      influences a vertex may carry, what it calls its bones, what rest pose it
      expects — so a fifth profile converts through the same code as the four
      declared (glTF/three.js, Unity, Unreal 5, Godot 4). Each declaration is
      checked against itself: in a right-handed system `right x up = -forward`,
      so the determinant of (right, up, forward) is -1 and +1 when left-handed,
      and all four agree with what they claim. Matching semantics rather than
      axis letters is what keeps the character walking forward — glTF's front
      `(0,0,1)` becomes Godot's `(0,0,-1)`, same letter, opposite sign, and
      copying the letter would leave every import moonwalking. A handedness
      change is a reflection, not a rotation, so transforms convert by
      conjugation `L' = A L A^-1`, which is still proper because
      `det(A R A^-1) = det R`; rotations go through their matrices rather than
      by negating quaternion components, since the component negations that
      circulate are right only for particular axis pairs. Three things then fall
      out and are measured rather than assumed: nonuniform scale survives
      exactly (a diagonal conjugated by a signed permutation is permuted), a
      mirrored bone stays mirrored (conjugation preserves the determinant), and
      a joint limit permutes its axes and swaps-and-negates its ends on any axis
      the mapping negates. Rest-pose work runs first and in the source's own
      coordinates, because it is a change of pose and not of frame: rebaking
      returns the new locals, the new inverse bind matrices AND the per-bone
      matrix the mesh must be baked through, because moving bones without
      recomputing the bind leaves the mesh behind, and recomputing the bind
      without baking leaves the mesh in the old pose under a skeleton in the new
      one. **Checks:** 29 tests; the whole library 199 passing across 49 files,
      up from 170/48 with nothing existing moved. glTF -> Unreal maps x->-y,
      y->+z, z->+x at determinant -1 and x100: 1 m up becomes `(0,0,100)`, the
      asset front becomes `(100,0,0)`, the character's left becomes
      `(0,-100,0)`, a bone scaled (2,3,5) becomes (5,2,3), a knee limit 0..140
      deg about x becomes -140..0 about y, and world x inverse-bind is still the
      identity to 1e-8. Round trips through all three other profiles return bone
      and inverse-bind matrices within 1e-9, including a rig carrying a rotated
      bone scaled (1, 1.6, 0.4) and a mirrored right upper arm; naming is
      reported separately, since glTF's own convention keeps whatever name
      arrives. A two-metre walk measures two metres forward in all three
      targets. Side pairs are classified four ways — parallel, reflected-proper
      with its negated axis named, reflected-improper, or unrelated with its
      residual — because which one holds decides whether a clip copies across
      the body unchanged. The Procrustes solve (Horn's quaternion method, which
      unlike an SVD route cannot answer with a reflection) recovers a known 47
      deg rotation to 1e-9 and degenerates to the minimal swing on one child; an
      arm chain dropped 40 deg lands on its targets to 1e-9 with bone lengths
      moving under 1e-12, and re-skinning the baked vertex at the new rest is
      the identity. Two defects were found building it: Horn's correlation
      matrix was transposed, which solves the INVERSE rotation and reads as a
      limb bending the wrong way while still passing any unit-length check; and
      negating a range end of 0 leaves -0. Not claimed: this does not DECIDE a
      rest pose (`decidesRestPose` is false — that measurement is
      humanoid-rest-pose-normalization's); the naming tables are conventions
      written down, not catalogues, and an unknown bone keeps its name while two
      bones on one name is blocking; only signed-permutation bases are accepted,
      anything else throws rather than being approximated. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.11.03._
- [x] **T.11.04** Generate diagnostic rest, raised-arm, crouch, twist and
      extreme joint poses appropriate to anatomy. Compute stretch/collapse,
      penetration and disconnected-part errors and render them. **Verify:**
      known bad weights fail despite a valid bind pose; all diagnostic evidence
      names the rig revision. _Done 2026-09-18. The item exists because a
      bind-pose check cannot see a weighting defect: at bind, skinning is the
      identity for every vertex whatever bone it is weighted to, so a forearm
      vertex weighted to the opposite shoulder still normalises, is still
      finite, still inverts and still sits where it was authored. The spec
      proves that rather than asserting it — the healthy rig and the corrupted
      one go through every bind check together and come out indistinguishable,
      and only the posed measurement separates them. Poses are generated from
      the rig's own structure, not read from a list: the skeleton is decomposed
      into an axial chain and the limbs off it, a pose is emitted only when the
      structure it needs exists, and one that is skipped says why. Three defects
      were found building it, each of which changed the design. REACH DOES NOT
      FIND A SPINE — following the furthest-reaching child from the hips runs
      into an arm, because a torso plus an arm is longer than a leg, so "twist
      the axial chain" would have twisted an arm; what separates a spine from a
      limb is symmetry, not length, so children are now paired across the
      sagittal plane and the chain continues into the one left over. PENETRATION
      AND DETACHMENT ARE ONLY MEANINGFUL RELATIVE TO REST — the test figure
      already crosses itself on 245 triangle pairs where its tubes meet at
      joints, which is ordinary (layered clothing, hair, stylised bodies), so
      the rest intersections are a baseline and only what a pose pushed together
      is reported; likewise a mesh modelled in pieces has several components
      before anything moves, so a part is detached only when a tear split it
      from what it was joined to. A RATIO ALONE IS NOT A TEAR — on a sound rig
      the crouch stretched a 0.0200-unit edge to 0.0832, 4.3x, simply because
      the bone under it is short and the rotation large, and nothing had come
      apart; a tear now also needs its two ends to share no bone holding them,
      which is the signature of a weight sent to the wrong bone rather than of a
      joint bending hard. **Checks:** 23 tests; the whole library 222 passing
      across 50 files, up from 199/49. The figure is a 19-bone biped in tubes,
      654 vertices and 1,296 triangles. Rest passes with stretch 1.00 and area
      1.000; raised-limbs 2.41x and 0.202; crouch 4.30x and 0.147; twist 1.06x
      and 0.717; extreme 5.61x and 0.083. The healthy rig DOES fail those poses,
      and correctly — coarse linear blend skinning at a 110-degree knee
      collapses triangles and folds the surface into itself, which is what
      corrective shapes are for — so `weightDefectSuspected` is reported
      separately from `status` and is true only when the mesh tore or came
      apart: false in every pose on the healthy rig, true on the corrupted one.
      The corruption is one ring of six forearm vertices re-weighted whole to
      `upperarm.R`; raised-limbs then fails with a detached part that is exactly
      those six indices and names `upperarm.R` as the bone they ran off with.
      The rig revision is a 64-bit FNV-1a over the hierarchy, bind matrices,
      weights and topology, rounded before hashing so a rig survives a profile
      round trip and still hashes to itself; it is stable across calls, differs
      after one weight change and after moving one bone, and appears in every
      pose SVG and in the contact sheet. Penetration is Möller's
      triangle-triangle interval test over a spatial hash, unit-checked on a
      crossing pair, a pair beside, a parallel pair above, a degenerate
      triangle, and a coplanar pair — which returns `coplanar` rather than a
      verdict, because a shared-plane overlap is a different question from one
      limb inside another. Not claimed: nothing here repairs anything
      (`repairsRigs` is false; T.11.05 owns that); the renders are orthographic
      SVG diagrams, not shaded previews; the thresholds are declared defaults
      and tightening them is shown to be what changes a verdict; and the
      per-anatomy pose magnitudes are a declared table, not a measurement.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.11.04._
- [x] **T.11.05** Implement bounded weight/bone corrections, user landmarks and
      manual rig import fallback with explicit affected regions. **Verify:**
      fixes improve deformation without worsening locked joints/materials;
      rollback preserves the best rig and unsupported repairs do not loop
      indefinitely. _Done 2026-09-18. T.11.04 says where a rig fails; this
      changes it, measures again, and keeps the change only if the rig got
      better. It ALWAYS returns the best rig it ever saw, never the last one it
      made: every candidate is scored by the same function, the best is held,
      and the spec checks the rig handed back re-scores to `bestScore` and that
      no rejected step beat it. What it may touch is a set and what it may not
      is a set — locked bones, pinned vertices and locked material groups leave
      the region before anything is diffused, and a step that makes the locked
      regions measurably worse is rejected even when the rig improved overall,
      because "better on average" is the argument that ruins the one joint
      somebody had already fixed. Weights are repaired by diffusion over rest
      neighbours with everything outside the region and every landmark held
      fixed as the boundary; joints by a bounded search of six axis offsets out
      to a fraction of the bone's own length, each rebuilt into a real bind pose
      because moving a joint without recomputing the bind makes the mesh jump.
      Three defects were found building it. THE BUDGET WAS UNDOING THE USER — a
      landmark is an L1 change of up to 2, so the per-vertex cap clawed it
      straight back and a vertex pinned to `neck` came out 0.3 `neck`; landmarks
      are now exempt. A LOCKED BONE HAS TO FREEZE ITS WHOLE WEIGHT COLUMN —
      locking only the vertices it dominates let the repair fix the tear by
      dragging the healthy neighbours onto the same wrong bone, a lower score
      and a worse rig. THE LOOP STOPPED TOO EARLY — it exited the moment the
      weight-defect flag cleared, which happens as soon as a vertex shares any
      bone with its neighbours, leaving it carrying 0.7 of its weight on the
      opposite arm; it now runs while rounds remain and each round pays for
      itself. It cannot loop: rounds capped, diffusion iterations capped, a
      fixed candidate list, and a round that buys nothing ends the run, with
      every exit naming which. **Checks:** 16 tests; the whole library 238
      passing across 51 files, up from 222/50. On a two-armed torso of 110
      vertices and 210 triangles with one five-vertex ring re-weighted whole to
      `upperarm.R`, the score falls 14862.95 -> 2638.98 -> 1188.29 -> 346.48 ->
      316.16 -> 271.61 -> 231.37 over four rounds; 19 steps tried, 8 kept; the
      stray weight on `upperarm.R` drops from 1.000 to 0.144 with the rest
      returning to the bones its neighbours use; each diffusion's largest
      per-vertex move is reported and never exceeds the budget (0.600, 0.600,
      0.434, 0.225). Running at maxRounds 0, 1, 2 and 3 never exceeds the cap.
      Locking `upperarm.R` ends at `manual-rig-required` with the stray weights
      untouched, and the manual import is then taken, beating it and recording
      the comparison; a manual rig no better leaves the repaired one in place;
      and three refusals are checked (an empty binding, a bone the skeleton does
      not have, weights summing to 0.4). Not claimed: a bounded repair removes
      the defect the diagnostics can SEE, it does not make the weights good — a
      vertex can stop tearing while still carrying weight on a bone nothing near
      it uses; diffusion cannot invent a bone the neighbourhood does not already
      use, which is what the manual fallback is for; the score is a declared
      weighting of the diagnostic counts, not a perceptual measure; and moving a
      joint moves the bind pose, so a mesh authored around the old pivot still
      needs an artist's eye. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.11.05._
- [x] **T.11.06** Scope facial blendshapes, eyes, fingers and clothing/hair
      binding as explicit additional capabilities, using cleared
      templates/manual imports where automation falls short. **Verify:**
      separate deformation/attachment tests; a body rig is not advertised as a
      complete facial or cloth rig. _Done 2026-09-18. The generators already
      existed (facial-rig-generation at 1,822 lines, eye-rig-generation,
      hand-rig-generation, clothing-rig-binding, speech-articulation-rig, each
      with its own capabilities object); what was missing is the layer above —
      the claim a DELIVERED rig may make and the evidence that earns it. A
      capability is earned by a measurement of that capability, never by the
      presence of code that could produce one. Two kinds, because they fail
      differently. A DEFORMATION capability (face, eyes, fingers) moves the
      surface it owns and is tested by driving its own controls with T.11.04's
      metrics restricted to its region — the same metric so a face and a body
      are comparable, narrowed so a bad elbow does not fail a face, which the
      spec proves both ways. An ATTACHMENT capability (clothing, hair) is a
      second mesh that has to keep following the first, and tearing is not its
      failure mode: A GARMENT THAT STAYS WHOLE WHILE SLIDING OFF THE HIP PASSES
      EVERY DEFORMATION TEST THERE IS. So each attached vertex's rest offset is
      taken in the frame of the body triangle it was anchored to, the body is
      posed, the anchor's frame carried along, and the gap from where the
      attached mesh's own skinning put the vertex is the drift; a vertex ending
      up behind a surface it was bound outside of has penetrated. Provenance
      (`automated`, `cleared-template`, `manual-import`) is recorded and excuses
      nothing — a failing manual import is still refused. The guard is the
      point: a capability without passing evidence is advertised as ABSENT WITH
      A REASON, never omitted, because a missing line reads as an oversight and
      "Not tested, so not offered." does not. With no evidence the sentence is
      exactly "Body rig only. No facial-blendshapes, eyes, fingers,
      clothing-binding, hair-binding."; with two passing it is "Body rig with
      fingers, clothing-binding. No facial-blendshapes, eyes, hair-binding.";
      and `assertLocal3DRigCapability` fails loud downstream with the manifest's
      own reason. **Checks:** 19 tests; the whole library 257 passing across 52
      files, up from 238/51. Covered: the kind split and both wrong-kind
      refusals; a region that holds and one that tears naming the control; the
      restriction proving a wrecked elbow does not fail a face; a capability
      claiming no region and one offering no controls, both refused; a sleeve
      following the arm through two poses and one skinned to the torso that
      stays whole and drifts; a purpose-built penetration case (a static body
      triangle, an attached vertex 0.1 above it skinned to a bone swung 180
      degrees through the surface) caught at exactly 0.1 deep; three
      malformed-anchor refusals; and the manifest's absence, failure,
      provenance, wrong-kind, duplicate-verdict and downstream-assert paths. One
      test was REWRITTEN rather than kept: the first penetration test scaled the
      garment inside the arm, but rest offsets are measured from the mesh as
      given, so its offsets read inward and the penetration branch — which only
      applies to a vertex bound OUTSIDE the surface — never ran; it passed while
      testing nothing it claimed. Not claimed: this generates no rigs
      (`generatesRigs` is false); a passing capability means it passed these
      tests on these controls, a floor and not an assurance an animator will
      like it; and the per-capability thresholds are declared defaults.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.11.06._

## T.12 Text-to-motion and a usable motion library

Dependencies: T.01 motion/data admission; T.04/T.11 skeleton contracts.

- [ ] **T.12.01** Integrate admitted MotionGPT3 text-to-motion/continuation/
      inbetween capabilities behind a versioned adapter, with duration, frame
      rate, skeleton and reproducibility metadata. **Verify:** real clips and
      supported prompt/control behavior; missing license/runtime prerequisites
      remain blockers rather than fabricated motion results. _2026-09-18, board
      tag: MotionGPT3 has no licence text yet; asking its authors is one of the
      owner acts of T.01.07._ `blocked:upstream`
- [ ] **T.12.02** Evaluate and integrate admitted MDM/DiP as the alternative
      motion backend, including segmented generation where supported.
      **Verify:** identical prompt corpus, boundaries, duration drift, memory/
      latency/cost and skeleton conversion; no claim of arbitrary narrative or
      nonhuman support without evidence.
- [x] **T.12.03** Build an original/redistributable preset library covering
      idle, walk, run, turn, jump, crouch, dance, gestures and attacks with
      loop/contact/ speed/anatomy metadata. **Verify:** each published clip has
      provenance, usable animation data and preview; number of validated clips
      is reported rather than implying a competitor-sized library. _Done
      2026-09-18. What was already here was the wrong shape:
      `humanoid-animation-library` is a CATALOGUE whose sources are Mixamo, the
      CMU Graphics Lab and KIT — it describes clips held by those parties and
      holds none of them, which is right for searching somebody else's
      collection and wrong for shipping. This is nine clips synthesised here
      from parameters written here, shippable because nothing was captured, and
      the file says what they are: parametric gait clips (each joint a small sum
      of sinusoids in the cycle's phase, legs half a cycle apart, arms opposite
      the leg on their own side; a jump is three timed segments; a wave is a
      decaying oscillation). `isMotionCapture` is false and the library
      publishes its own scope statement beside the count. NOTHING IS ASSERTED
      THAT CAN BE MEASURED — and the validator rejected my own clips five times,
      each a real error. (1) FEET SLIDING 1.16 m: a stride is not a parameter,
      the foot's travel under the body is whatever the hip swing and leg length
      make it, so the root is now derived from the stance foot and the slide is
      0.000 m. (2) FEET RISING 0.12 m WHILE PLANTED: the height was still a sine
      on top; deriving it from the stance foot produces the body's vertical bob
      for free, which is the real mechanism. (3) CLAIMING A FOOT IS STILL DURING
      DOUBLE SUPPORT: with both feet down the body follows their average, so
      neither is exactly still — contacts are single support only. (4) A RUN
      SLOWER THAN A WALK (0.25 m/s): interpolating the root across the flight
      drops the flight's travel out of the stride; nothing pushes the body
      horizontally off the ground, so it carries its take-off velocity. (5) THE
      STANCE WINDOW ON THE WRONG HALF OF THE CYCLE: centred on the footfall, the
      moment the foot is furthest FORWARD, so half of every stance ran the
      swing, whose contribution to the advance is negative; recentred, the walk
      went 0.44 -> 1.23 m/s and the run 0.25 -> 4.60. Two smaller ones: a
      two-step sway declared both feet planted while its knee tracks lift them
      (contacts are now read off the knee curves) and a standing swing animated
      a hip while claiming the foot was down. **Checks:** 18 tests; the whole
      library 275 passing across 53 files, up from 257/52. All nine validate:
      idle 0.000 m/s, walk 1.235, run 4.597, turn 0.000 (and NO contact declared
      — a turn in place pivots and shuffles), jump 0.438, crouch 0.005, dance
      0.008, wave 0.000, attack 0.000; every declared contact slides 0.000 m.
      The validator fails on a 40-degree loop break, a contact declared over the
      whole walk, a declared 6 m/s, a joint at 200 degrees, a bone the skeleton
      lacks, a ragged track, a NaN angle and a contact past the end — all at
      once, because it collects rather than throwing on the first; and
      tightening `maxJointDegrees` to 10 drops clips from the published set with
      the count. LOOP CLOSURE IS NOT "THE ENDS MATCH": a cycle sampled at N
      frames stops one frame short, so closure is the wrap step against the
      largest step the clip takes anywhere else, which also survives a
      deliberate kink — the dance's `max(0, +/-sin)` knee curves failed the
      naive version at 1.88 degrees while looping perfectly. Every clip carries
      origin, generator, parameters, licence and a distinct 64-bit content hash,
      plus a preview (six poses of a twenty-segment figure with the contact
      timeline); two builds are byte-identical; and a spec strips the comments
      and asserts the CODE names no mixamo/cmu/amass/smpl/http/fetch. Not
      claimed: these are not motion capture, carry no performer style and will
      not stand in for one — they are a floor to ship while T.12.07's
      licensed-data path is open; nine is nine and a competitor's catalogue is
      tens of thousands, in different units (performances vs parameters); and
      every clip is authored for the humanoid reference skeleton, so quadruped
      and winged gait are separate generators. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.12.03._
- [x] **T.12.04** Support user-owned BVH/FBX/GLB motion import and
      Mixamo-compatible mappings with scoped rights and attribution. **Verify:**
      actual clip parsing, frame rate/units/root conversion, unauthorized
      sharing refusal and no dependency on downloading or republishing Adobe's
      catalog. _Done 2026-09-17. `@isis/3d-post-pipeline/motion` decides a
      user's file by its signature, reads it with the three.js loader for that
      format and returns one canonical clip in metres with +Y up beside a record
      of every assumption it had to make: glTF is metres by specification, an
      FBX says its centimetres per unit in its own GlobalSettings, and a BVH
      says nothing, so the caller's unit wins or the hips' height decides, and a
      declared unit that would stand a humanoid outside 0.2 to 2 metres is
      reported and measured instead; the rest skeleton's own longest extent
      settles the up axis whenever it disagrees with the file, which is how a
      Blender BVH is recognised as +Z up; the declared frame rate is kept beside
      the measured key spacing and a resample reports the largest joint
      displacement it introduced; and the hips' horizontal path is measured,
      with in-place removing it and saying how much went. Mixamo-compatible
      names reach humanoid slots through prefixes, namespaces, the class suffix
      FBX packs into a name, any separator and zero-padded indices, from one
      table now shared with the older Mixamo pipeline. Rights travel with the
      clip and are enforced rather than described: a channel the owner marked
      prohibited or pending review is refused, and so is one that requires
      attribution the owner did not give. Blender wrote the rig of a real Meshy
      job out as BVH and as an FBX with Mixamo-prefixed bones, and all three
      files import to within 9.9 mm of each other across 22 joints on a rig
      whose hips stand 0.474 m up, while two real meshes with no animation are
      refused. bellona's FBX importer was measured and set aside for this: it
      does not compose a bone's PreRotation, so it returned a rig with its foot
      above its head. Nothing is downloaded: a spec asserts the module names no
      host and calls no fetch, and every fixture is bytes written here.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.12.04._
- [x] **T.12.05** Decompose narrative requests into a timed motion plan with
      actions, contacts, transitions, object interactions and shared anchors.
      Select/generate each segment under the project budget. **Verify:** a
      walk-stop-look-turn-run sequence preserves order and duration; unsupported
      actions are explained rather than replaced silently. _Done 2026-09-18. The
      planner's job is to be specific about what it cannot do: an action nobody
      can animate that comes back as SOMETHING animated is the worst outcome,
      because the sequence plays, nobody notices, and the thing the shot needed
      never happens. The tracker's own sequence plans as walk 0.00-3.00s
      (walk-forward), stop 3.00-4.50s (idle-breathing), look 4.50-6.50s
      UNSUPPORTED, turn 6.50-7.70s (turn-in-place-left), run 7.70-11.70s
      (run-forward): order is the request's order, every duration is the one
      asked for, the total is 11.70s, and the `look` slot is still two seconds
      long in its place with a null clip and a null category — nothing
      substituted. The finding names the word, lists the categories that do
      exist and points at T.12.01/02/07; the plan is not satisfiable and says
      why. It does NOT parse English (`parsesNaturalLanguage` is false): a
      38-word lexicon maps to the nine preset categories and a word outside it
      is unsupported rather than guessed. Duration is negotiated — a looping
      clip fills its slot with whole cycles plus a cut one (and reports no cut
      when the slot is a whole number of cycles), a one-shot holds its last pose
      or is cut, and cutting matters more than holding because a jump cut at
      0.55s ends in the air (blocking) while a crouch cut short does not
      (warning). TWO REAL DISTINCTIONS THE FIRST VERSION GOT WRONG. (a) PLANTED
      IS NOT GROUNDED: the junction check read "no foot declared planted" as
      "airborne", which made `turn-in-place-left` — correctly declaring no
      contact, because a turn shuffles and neither foot is STILL — break every
      junction it took part in, though a turn has both feet DOWN. Clips now
      declare flight frames and segments carry startsAirborne/endsAirborne
      separately, so a junction is `continuous` when a foot stays still across
      it, `foot-swap` when both sides are grounded but the weight changes, and
      `contact-break` only when someone is genuinely in the air. (b) THE FLIGHT
      DECLARATION ITSELF: inferring it from absolute foot heights read 29 OF THE
      WALK'S 33 FRAMES AS AIRBORNE, because the root derivation holds the STANCE
      foot level and the floor drifts between stances; the generator knows which
      frames have nothing down, so it declares them and the validator checks the
      declaration against the contacts instead (a frame cannot be airborne while
      a foot is planted on it, nor outside the clip — both refusals tested).
      Declarations now read walk 0, turn 0, idle 0, run 6 (two phases of three
      per cycle), jump 14. **Checks:** 27 tests; the whole library 304 passing
      across 54 files, up from 275/53. Also covered: shared anchors (two steps
      naming `statue` get one anchor listing segments 0 and 2, and an unanimated
      step keeps its anchor); the time budget refusing 80s against 60s; the
      generation budget counting two units for `look` and `whistle` and refusing
      to spend them because no generator has cleared admission; a category whose
      clips all failed validation reported rather than fallen back from; case-
      and space-insensitive lexicon matching; and the same request planning
      identically twice. Not claimed: no natural language, no motion generated
      (`generatesMotion` is false), transitions are REPORTED not authored
      (blending the poses across them is T.13's), and the lexicon is 38 words
      over nine categories — a word outside it is a gap, which is the point.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.12.05._
- [x] **T.12.06** Provide motion search/preview/selection, reusable clip
      variants and provenance-aware replacement. Define a fallback if neither
      research motion stack clears admission: cleared procedural/preset motion
      now and a separately scoped licensed-data training/adaptation task for
      generation. **Verify:** the release matrix distinguishes preset motion
      from generated text-to-motion and leaves missing generation parity open.
      _Done 2026-09-18. Search shows its working: every match carries what it
      matched on and the score IS the count of those, an integer a reader can
      check rather than a weighted number to take on trust; every clip that did
      not match carries its reason; and a query that empties the result says
      which filter did it. Filters are text, category, anatomy, looping, speed
      range, duration range, a required planted foot and grounded-only. Variants
      are derived, declared and RE-VALIDATED — never trusted for having a valid
      parent, which the spec proves by retiming a deliberately broken parent and
      getting `accepted: false` with no preview. Three transforms: retime (the
      same frames at a different rate — a 2x variant keeps all 33 frames, halves
      the duration, doubles the declared speed and still measures its contacts
      as planted), mirror, and trim (re-zeroed at the root, no longer looping,
      speed recomputed, the parent's flight frames carried across and shifted).
      MIRROR IS THE ONE WORTH GETTING RIGHT: reflecting a rotation by an
      improper matrix gives R(Ma, -theta), so the axis reflects AND THE ANGLE
      NEGATES; doing only the axis half is the bug everybody writes once and it
      produces a walk whose knees bend forwards. Both halves are checked on a
      real hip track, and mirroring twice returns the original curves exactly.
      Replacement is checked against provenance and not just fit, because fit is
      necessary and not sufficient — a replacement must be at least as free to
      ship or a scene quietly acquires a licence obligation nobody recorded.
      Four refusals are tested: a weaker licence, a different origin, a
      different anatomy, and a clip that begins or ends in the air where the
      original did not. A different CATEGORY is allowed and noted, because
      standing a run in for a walk is a decision somebody may want to make with
      their eyes open. The release matrix has five rows: preset-motion,
      preset-motion-search-and-selection and preset-motion-variants AVAILABLE
      with nothing blocking them; generated-text-to-motion and
      generated-motion-parity-with-preset OPEN on T.12.01, T.12.02 and T.12.07.
      `generatedTextToMotionAvailable` is false and `parityOpen` is true with no
      code path that sets either otherwise; the summary states the preset
      library "is not a substitute for generation" and that "parity between them
      stays open". The preset row COUNTS `validatedClipCount` rather than
      describing it — halving the library halves the number while the generated
      rows do not move — and every open row names what it waits on while no
      available row does. **Checks:** 24 tests; the whole library 328 passing
      across 55 files, up from 304/54. Not claimed: no motion is generated
      (`generatesMotion` false, `claimsGenerationParity` false); the licence
      rank has one entry because one licence exists here, and anything off the
      list ranks zero and so can never replace something on it, which is the
      failure direction worth defaulting to; and retime does not resample — a
      variant needing new in-between poses is interpolation, a different piece
      of work. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.12.06._
- [ ] **T.12.07** _(added 2026-09-14 from T.01.02)_ Licensed motion data and
      body model for generated text-to-motion: a commercial AMASS and
      SMPL-family licence from Max Planck (through Meshcapade) or original
      motion capture on a cleared skeleton; then train or adapt a model on it
      and review it through the admission check. **Verify:** the training-data
      licence rule passes on the new checkpoint; until then the release matrix
      keeps generated text-to-motion open and C7 ships preset and procedural
      motion only. _2026-09-18, board tag: needs a commercial AMASS and
      SMPL-family licence or original motion capture, neither of which exists
      yet._ `blocked:external`

## T.13 Retargeting, blending and animation QA

Dependencies: T.11–T.12; numeric metrics precede critic interpretation.

- [x] **T.13.01** Implement Blender retargeting with anatomy/bone maps, rest
      poses, units, root motion and in-place options. **Verify:** humanoid and
      separately supported creature rigs maintain pose/action semantics;
      incompatible skeletons fail with an actionable mapping requirement. _Done
      2026-09-17. A gpu-worker motion-retarget job runs a versioned Blender
      script that reads each mapped source bone's pose as its change from its
      own rest and applies that change to the target's rest, so the two rest
      poses cancel, and writes rotation alone, leaving every pose bone's
      location and scale untouched so the target keeps its own proportions
      however differently the source is built. The root's travel is scaled by
      the ratio of the two rigs' heights, each measured as its root over its own
      lowest rest joint, which needs no feet and so holds for a creature as
      well; in place drops the horizontal travel and keeps the vertical; parents
      are posed before children; and the scene frame rate is taken from the
      clip's own keys before import so a thirty frame clip is not baked at
      twenty four. Nothing the script reports is trusted: both clips are
      re-imported and measured, bone direction by bone direction, against the
      target's own rest lengths, the height ratio and the clip's timing. The
      real Meshy rig onto a quarter taller copy of itself keeps every bone
      within 0.0017 degrees over 357 comparisons with no bone changing length
      and a stride of exactly one and a quarter times the source's, in place
      travels nothing at all, and a Blender built quadruped onto one whose legs
      are sixty per cent longer keeps every direction and travels exactly one
      and six tenths as far. A map naming a bone neither rig has stops the
      script before it poses anything and fails the job with that name, and
      seven spec cases prove the measurement fails a stretched target, a limb
      posed another way, an unscaled or a walking in place root, a map naming a
      missing bone and a clip that lost time. Two real defects were found and
      fixed on the way: setting a pose bone's matrix leaves its location and
      scale unkeyed, which pulled bones off their parents until they were
      zeroed, and the up axis a file declares must be believed over a rest
      skeleton's longest extent, because a quadruped is longer than it is tall.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.13.01._
- [x] **T.13.02** Blend clips with controlled timing, phase/contact alignment,
      transitions and continuity of root/joint velocities. **Verify:** looping
      walk/run and narrative sequence fixtures have no transition snaps or
      cumulative timing drift outside declared thresholds. _Done 2026-09-17.
      `blendMotion` in `@isis/3d-post-pipeline/motion` lays segments of one rig
      end to end, each repeatable, with a cross fade over the join that
      interpolates local transforms, rotations by spherical interpolation and
      positions linearly, under a smoothstep weight. Each frame carries a
      contact signature saying which contact bones are down, and an incoming
      segment is started at the offset whose signature best matches what is
      playing, with the shift and how well it matched both reported. The
      incoming root is offset to where the outgoing one stands when the fade
      starts rather than where it ends, because stitching to the far end drags
      the root forward through the fade, measured as a step two and a half times
      the walk's own. A fade is rounded to whole frames, so the drift is at most
      one frame per join and grows no further, and the report carries the
      expected length, the actual one and the difference. No join is judged by
      the blender's own word: the result is measured with the T.13.03 metrics
      and the worst jerk within two frames of a join is compared with the worst
      anywhere else. A walk looped three times keeps its timing, adds no jerk
      over the stride it came from and advances instead of resetting; a stride
      started half a cycle out of phase is realigned to better than nine tenths
      agreement; a walk, idle and walk sequence stitches the idle three quarters
      of a metre along and never steps the root further than twice what the walk
      does; and the same sequence blended with no fade and no stitching is
      caught, with more than three times the jerk concentrated at the join and a
      root that teleports. Blending two different rigs, an empty list and a
      segment that plays no time are each refused. The walk fixture also found a
      real defect in the T.13.04 lock, which is fixed and re-measured. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.13.02._
- [x] **T.13.03** Compute contact-conditioned foot velocity, ground/object
      penetrations, joint limits/velocities, balance proxies and root
      trajectory. **Verify:** known skating, hyperextension, penetration and
      discontinuity fixtures fail; mass-based COM claims require an actual mass
      model. _Done 2026-09-17. `measureMotion` in
      `@isis/3d-post-pipeline/motion` reads a clip's joint positions over time
      at its own frame rate and reports, beside the rig's own height so one
      profile serves rigs of any size: which bones are in contact and how fast
      each slides while it is down, the deepest anything goes below the ground,
      the angle at every joint with one child, the fastest a bone direction
      turns, the largest single frame jerk away from the path the previous two
      frames drew, and the root's path, displacement and vertical range. A
      joint's angle is signed by the plane its two bones make in the rest pose,
      so a knee bending the way it cannot reads past a hundred and eighty
      degrees rather than looking like a deep bend, which an unsigned angle
      cannot tell apart. Balance is the root's ground projection against the
      feet that are down, named a proxy, and no centre of mass is claimed at all
      unless the caller supplies a mass per bone, in which case it is computed
      and reported beside it. Six spec cases show a clip that stands still
      passing every check and each defect made on purpose failing its own and no
      other: a planted foot drifting half a metre a second, hips sunk eight
      centimetres, lower legs swung thirty five degrees past straight and a
      single frame hop. On real motion the measure earns its keep: the Meshy
      Alert clip's left toe slides 0.260 m/s while planted, seven times the
      allowance, and the same clip retargeted onto the taller rig slides exactly
      a quarter more, so the measure scales with the rig. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.13.03._
- [x] **T.13.04** Add bounded IK foot/hand contact locks, hip/root adjustment,
      transition repair and optional validated clothing collision/simulation.
      **Verify:** repaired motions improve target metrics without introducing
      worse failures; cloth simulation and rigid skin binding remain distinct.
      _Done 2026-09-17. `repairMotion` in `@isis/3d-post-pipeline/motion` holds
      a run of frames where a contact bone is down at the place it landed and
      re-solves the two bones above it with two-bone inverse kinematics that
      keeps the bend plane the limb already had, carrying the correction between
      runs while the foot is in the air, where moving it costs nothing. Which
      bone a rig stands on is the rig's business, so every bone the profile
      counts as a contact gets a chain and the one furthest out along the limb
      wins when several are down, which is what the real Meshy rig needed
      because it stands on its toes rather than its feet. A lock out of reach
      lowers the root by the least that helps and never by more than a declared
      fraction of the rig's height, and whatever reach is still missing is given
      up rather than taken by stretching a bone. A frame that leaves the line
      its neighbours draw is replaced by their average, but only at the top of a
      spike, because its neighbours look bent too and pulling them in makes a
      new spike, as an earlier version did. No cloth is simulated and none is
      claimed. Every case is judged by measuring before and after with the
      T.13.03 metrics: on the real clip the left toe goes from sliding 0.260 m/s
      while planted to 0.0123 m/s, the clip goes from failing its contact check
      to passing all five, penetration stays a fortieth of its allowance, jerk,
      joint speed, joint ranges and root path are unchanged, and the whole rig
      moved at most four centimetres. Six spec cases add a locked drift with
      every bone the same length to nine decimals, hips left alone when the lock
      is in reach, a root moved within its bound with the unreachable frames
      counted when it is not, a fourteen centimetre hop smoothed away, and an
      assertion that the module simulates no cloth. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.13.04._
- [x] **T.13.05** Render time-labelled diagnostic contact sheets plus frames
      around detected events, alongside numerical telemetry, for visual motion
      criticism. **Verify:** short defects between uniform samples remain
      detectable; frame evidence is correctly ordered and bound to the exact
      clip/rig, without requiring native video input from the controller. _Done
      2026-09-17. A sheet is planned in two parts and every frame says which
      part it came from: uniform samples at a declared spacing, and a window of
      frames around each event the T.13.03 metrics found, the fastest slide of a
      planted foot, the deepest penetration, a joint out of its range, the
      fastest turn and the largest jerk. The window is what makes a short defect
      visible, because a jerk is a second difference and a one frame pop scores
      highest on the frame after it: a clip popping at frame seventeen and
      sampled every ten frames has no uniform sample there, and the plan carries
      seventeen, eighteen and nineteen with the reason attached. A gpu-worker
      job renders each planned time in Blender with Workbench from one
      orthographic camera framed over the bounds of every pose it will render,
      taken from the evaluated scene because an object's own world matrix is not
      enough and a pose bone's head is in the armature's space, and burns the
      time and the reason into the image. Before a sheet is delivered it is
      checked: one image per planned frame, none of them blank, tiles in the
      plan's own order row by row, and a manifest bound to the clip by name and
      to the rig by a fingerprint of its bones and their parents. On the real
      Meshy clip that is a four by five sheet of twenty labelled tiles whose
      event frames include the planted toe sliding at one point nine seconds,
      with the telemetry that chose them beside it. Nothing needs video: every
      artefact is a still. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.13.05._
- [x] **T.13.06** Certify final animated assets per anatomy/target with
      quantitative thresholds, critic findings and artist escalation where
      needed. **Verify:** regenerated clips rerun rig/motion/export gates,
      failures retain playable previews, and no text critique alone produces an
      animation-ready badge. _Done 2026-09-17. A certificate names a profile per
      anatomy and target, and the motion gates are measured inside the
      certification from the clip being certified, so no argument a caller
      supplies can fill one and no critique can produce a badge. The gates that
      cannot be recomputed there are accepted only when they are bound to the
      asset: the diagnostic sheet by the clip's hash and by its own clip and rig
      check, the retarget by a fingerprint that carries the rest pose to a tenth
      of a millimetre so a rig of another size cannot stand in, the delivery by
      the hash of the file every format was exported from. A gate with nothing
      behind it is missing and missing blocks; a blocker finding takes a badge
      away when every number is good, and an escalation records who asked and
      why, so text can subtract and never add. The web target asks for the five
      motion gates and a sheet, the engine target adds the retarget and the
      delivery, the film target tightens the slide to a third and the jerk to a
      half, and the quadruped profile empties the humanoid knee and elbow ranges
      rather than borrowing them. End to end on real bytes with Blender, a clip
      whose planted foot slides is blocked at a third of a rig height per second
      against eight hundredths and keeps both previews, the file itself and its
      eleven tile sheet; the same clip repaired is different bytes, so the old
      certificate is stale, every gate runs again and it passes at four
      hundredths; and that passing file with a rave and no evidence behind it is
      still refused with three gates never measured. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.13.06._

## T.14 Scene assembly, selective replacement and rendering

Dependencies: T.04; available T.05–T.13 capabilities, T.08 for agent edits.

- [x] **T.14.01** Assemble reusable scenes with semantic objects, layout
      anchors, constraints, instances, background, lights and cameras.
      **Verify:** object insertion/removal and saved scene reopening preserve
      relationships and source asset references; independent objects do not
      collapse into one mesh. _Done 2026-09-17. The scene document of T.04.03
      gained a layer above its nodes: an object is one root node and its
      subtree, with bounds and anchors — frames whose normal points out of the
      object's material into free space, so mating two anchors makes their
      normals antiparallel and the surfaces meet. A chair's base normal points
      down and a table's top points up, and that one rule is what places
      everything. Placement constraints, on and against, are solved exactly and
      in dependency order, each writing only the placed object's root rotation
      and translation and keeping its scale; the turn about the anchor's normal
      and the slide across its plane are what put two different things on one
      table top, and the anchor's radius is what they have to fit. Clearance and
      region constraints are not solved at all: they are measured on the objects
      that were placed and reported as findings, so a chair left inside another
      chair stays there and the report says by how much. A frame that cannot be
      mated is refused rather than straightened — a non-uniform scale, a parent
      that shears, either one mirrored — because a mating frame is angles and
      only a similarity keeps them. The semantic layer travels in the glTF
      scene's own extras, so a scene written to a binary file and read back
      reopens with its objects, anchors, constraints and background, and solves
      to the same places; the registry already stores the whole document as
      JSONB, so nothing there had to change. Insertion parses the whole document
      afterwards, so it either leaves a valid scene or is refused with every
      problem it would have caused and changes nothing. Removal never drops a
      relationship quietly: by default it refuses and names what sat on or
      inside the object, detaching leaves what merely stood on it exactly where
      it stood, and removing takes the dependents down with it — and what is
      left still names every asset revision it is made of. Objects staying
      separate things is measured twice: each object is moved in turn and
      exactly its own subtree follows, and the written file is read back and
      checked for a mesh holding two different asset revisions, an instance
      whose mesh is gone, geometry no revision accounts for and an object whose
      root did not come back, while two chairs instancing one revision share one
      mesh and are reported as sharing, not merging. Twenty-two spec cases over
      a room with a table, a tray parented to it, two chairs, a lamp, a picture
      on the wall, a camera, a sun and an environment background: thirteen
      validation faults listed together from one scene, a cycle named once, the
      five placements landing where hand arithmetic puts them through a turned,
      moved and doubled parent, and the three measured findings pinned to
      exactly −0.1 m of overlap, the square root of 0.62 squared plus 0.12
      squared across the table top and 0.5 m outside the region. The older
      semantic scene graph in the same library was left alone: its transforms
      are Euler angles of unstated order, the fault T.04.03 found and fixed, and
      its placement rules engine approves whatever position it is given without
      moving anything, so neither could carry this. Evidence:
      docs/agents/isis-3d-studio-evidence.md._
- [x] **T.14.02** Implement object/part selection and bounded defective-region
      replacement with alignment, connection cleanup and material rebaking.
      **Verify:** a handlebar/ear replacement preserves locked components and
      silhouette; unsupported region inference routes to manual/procedural
      repair, never a claim that the neural backend can natively inpaint any
      mesh. _Done 2026-09-17. The operation is deliberately narrow: a connected
      set of the target's triangles whose removal leaves exactly one hole, and a
      donor patch with exactly one boundary loop. Anything else is refused by
      name — two pieces at once, a region whose removal cuts the mesh in two, a
      closed donor with no boundary to join, the whole mesh, a region that cuts
      into a lock. The donor is aligned by a similarity fitted to the two
      boundary loops with Umeyama's least squares, the rotation found by Horn's
      quaternion method so no singular value decomposition is needed, searched
      over every cyclic offset and both ways round; when the loops have the same
      number of vertices the correspondence is then refined onto the vertices
      themselves, which is what lets an exactly matching donor weld instead of
      bridge. The join is a weld when every corresponded pair lands within the
      tolerance, and otherwise a bridge of triangles walked by arc length
      between the two rims, which handles rims of different lengths without
      moving a vertex of either. Material slots are rebuilt by a stated rule —
      the patch keeps the donor's or takes the region's, and each seam triangle
      takes the slot of the face whose edge it is anchored on — and the target's
      texture coordinates travel to every vertex the edit kept, with NaN and a
      list at every vertex the patch brought, because a geometry edit has no
      coordinates to give them and the rebake of T.09.04 is what answers that.
      Region inference is where the item bites: asking for a part no supplied
      segmentation names is refused with the four routes that do work — explicit
      faces, a segmentation the caller already has, a procedural rebuild, manual
      repair in the Blender lab — and the message says plainly that nothing in
      this pipeline turns a description into triangles. Every claim is measured
      on the result rather than asserted: the topology before and after, that
      every directed edge is used once and no edge by three faces, that the
      enclosed volume kept its sign so the patch did not go in inside out, that
      every vertex the edit kept is in the same place to the last bit and each
      lock's largest movement is exactly zero, and the silhouette rasterized
      from three directions with the pixels that changed outside the region the
      edit was allowed to touch counted separately. Seventeen spec cases on a
      watertight head whose two ears are cones raised over a socket in its
      sphere: a 20-sided donor cone posed 2.3 times too big, turned 0.7 rad
      about a slanted axis and moved metres away is fitted back to within a
      seventh of the socket's 0.894 m perimeter, the head and the locked other
      ear do not move at all, the surface closes watertight again, and the
      changed pixels outside the ear are zero in all three views while the ear's
      own outline really changes. A donor built over the socket's own loop welds
      all eight pairs with no seam band at all, recovering its 1.7 scale to six
      figures. Evidence: docs/agents/isis-3d-studio-evidence.md._
- [x] **T.14.03** Track downstream dependencies after geometry/material/rig
      edits and rerun only invalidated UV, bake, rig, motion and export stages.
      **Verify:** unchanged artifacts are reused byte-for-byte, vertex changes
      invalidate skin correspondence and stale downstream outputs cannot
      publish. _Done 2026-09-18. A finished run leaves a ledger: for each stage,
      the settings it ran at, the sha-256 of every artifact it consumed and of
      every artifact it produced, and the fingerprint those add up to. The
      planner walks the graph against that ledger and marks each stage reuse or
      rerun with the reasons it has — never ran, edited, an input changed, an
      input is missing, the settings moved, something upstream is rerunning. Two
      decisions make it honest rather than optimistic. Dependencies are read
      from the artifacts a stage consumes, not from the order stages run in, so
      retexturing does not rebind a skeleton — the rig runs after texturing and
      reads none of its output, and the plan says so by naming the artifact that
      did not change. And a stage that is going to rerun has no output hash yet,
      so nothing invents one: its outputs are marked pending, which makes
      everything downstream of it rerun and leaves its fingerprint null until
      bytes exist. Skin correspondence is reported on the rig stage from what
      actually happened to the mesh: lost when vertices were added, removed or
      reordered, or when the mesh is being rebuilt at all and nobody yet knows
      what its vertices will be; kept when the same vertices only moved, since
      per-vertex weights still index the same vertices even though the bind pose
      has to be recomputed. An edit is not overwritten by the stage that made
      the artifact: that stage still reuses, and the plan names the output the
      edit replaced — and when the stage does have to rerun, the plan says which
      edit that throws away instead of losing it quietly. Publishing is gated on
      the same ledger: an artifact whose producing stage is in the rerun set is
      stale and refused by name, and a run with any stage left to run is refused
      too. Eleven spec cases run a real seven-stage pipeline whose stages turn
      the bytes they read into bytes of their own, then edit an artifact and run
      the whole pipeline again from the edited state: the stages the plan reuses
      are exactly the stages whose bytes are identical — compared as buffers,
      not only as hashes — and the stages it reruns are exactly the ones that
      really changed. Evidence: docs/agents/isis-3d-studio-evidence.md._
- [x] **T.14.04** Add camera presets/trajectories, shot framing, keyframes and
      object/character animation on a scene timeline. **Verify:** camera
      collision, clipping, duration and shot continuity checks; imported
      animated GLBs and manually keyed objects play and save with the correct
      timebase. _Done 2026-09-18. A timeline is a frame rate, a duration, tracks
      and shots. A track keys one property of one node — translation, rotation,
      scale, a perspective camera's field of view, a light's intensity — with
      glTF's three interpolations, because a scene's animation has to survive
      the round trip into a glTF animation without being reinterpreted;
      rotations interpolate as quaternions along the shorter arc, which an Euler
      triple cannot promise. The timebase is explicit and enforced: a key that
      does not land on the frame grid is an issue naming the drift, not a
      rounding done quietly, and the tolerance is a microsecond because glTF
      stores times in float32 accessors while the mistake this catches — a clip
      keyed at thirty and read at twenty-four — is tens of milliseconds. Camera
      moves are generated rather than described: an orbit, a dolly or a hold
      writes real keys at real frame times with the rotation that points the
      camera's own minus-Z at what it is looking at, and framing solves the
      distance that fits a subject's bounding sphere in whichever of the two
      fields of view is narrower. The checks play each shot and measure it: the
      camera inside a solid and by how far, anything it can see crossing its
      near or far plane and by how much, how much of the shot its subject is off
      screen for, and any teleport between two samples or across a cut that
      reuses one camera. Two honest limits are stated in the code rather than
      papered over — an object the camera is meant to be inside is a container
      (every architecture object, by default), because a box one is inside
      cannot be judged for nearness, though its far wall still can; and the
      frustum test is a box against the frustum's planes, not corners against
      the cone, because an object filling the frame has every corner past its
      edges. Fifteen spec cases: fifteen validation faults from one timeline at
      once, the three interpolations against hand arithmetic, a turn from zero
      to three hundred and fifty degrees going the short way, a generated orbit
      whose forty-nine keys all sit on the grid at exactly three metres and
      point at the table, framing at the distance the formula gives, a clean
      orbit with no findings and its subject wholly in frame for every sample,
      and a camera driven into the table, past its near plane, past a shortened
      far plane, off its subject and teleported forty-four metres — each caught
      with its number. A clip written into a glTF animation as real channels and
      samplers, through a binary round trip and back, is the same clip with its
      cubic-spline tangents, and an import that is not told the frame rate
      refuses rather than guessing one, while being told twenty-five reports the
      drift on every key. Evidence: docs/agents/isis-3d-studio-evidence.md._
- [x] **T.14.05** Render actual scene stills, turntables and MP4 sequences with
      bounded resolution/duration and optional existing Isis audio/video
      handoff. **Verify:** exported frames match scene revision/camera/time,
      audio sync and lineage survive handoff; generative video is labelled
      separately from a faithful deterministic scene render. _Done 2026-09-18. A
      render is planned before it is run: the frames it will produce, each with
      the moment it is of, the camera the covering shot names and the file it
      goes to, together with the resolution, the rate and the lineage — which
      scene, which revision, which timeline, and the content hash the registry
      gave that scene rather than one invented here. Bounds are refusals and
      never clamps: a resolution, a rate, a duration or a frame count past the
      limits stops the plan, as does a moment no shot covers or a camera the
      scene has not got. A turntable is a timeline the framing solver builds —
      the orbit's radius is the distance that fits the subject — so the subject
      is in frame by construction, which the shot checks of T.14.04 then
      confirm. What comes back is checked against the plan field by field and
      frame by frame, and the handoff to the existing Isis audio and video lane
      refuses frames that are not the ones planned, carries the lineage and the
      renderer with them, and measures how the audio lines up: its offset, what
      it covers, what it leaves silent and what runs past the end. The label is
      carried rather than implied — a generated clip gets an origin of its own
      that keeps it out of the deterministic lane, and says in its own note that
      what it shows is the model's and not a measurement of the scene. It runs
      for real: a versioned Blender script places the camera the plan sampled,
      converting glTF's Y-up frame with the same turn Blender's own importer
      applies, and ffmpeg muxes the frames at the plan's own rate with ffprobe
      reading the file back — a sequence whose frame count or rate is not the
      plan's fails the job. Eleven library specs and four with a real Blender: a
      turntable of a box with a bump renders eight frames at 128 pixels, all
      eight different, each with the subject centred at between 5 and 75 per
      cent of the frame — which is what proves the camera landed in Blender's
      world where the plan put it in glTF's — and the MP4 comes back at eight
      frames and eight frames a second. Evidence, with the strip and the
      manifest: docs/agents/isis-3d-studio-evidence.md._
- [x] **T.14.06** Support iterative natural-language scene changes and manual
      edits with undo/redo, locks, previews and revision restoration.
      **Verify:** a scene layout/camera change does not regenerate accepted
      assets; restored scenes re-render consistently and concurrent role
      permissions prevent unauthorized or stale modifications. _Done 2026-09-18.
      T.04.04 already gave a scene an edit history with locks, optimistic
      revisions, undo, redo and restore; this is the layer in front of it for
      changes that arrive as a request. A proposal carries the instruction in
      the words it was asked in, the entities those words were resolved to, the
      typed edits they became, and the actor and role behind them. Nothing here
      reads English — resolving words to nodes and objects is the director's or
      a person's — and what this does instead is check that resolution: a change
      touching something the instruction was not resolved to is refused by name,
      and so is a resolution naming something the scene has not got, which is
      what stops an agent quietly moving what it was not asked about. A preview
      is a dry run that applies the batch to a copy, lists every reason it would
      be refused rather than the first, and commits nothing. The distinction the
      item turns on is carried by the preview: moving a chair or a camera makes
      the render stale and no asset work at all, while pointing a node at
      another asset revision makes that asset's UV, texture, rig and motion work
      stale too — so a layout change cannot regenerate an accepted asset,
      because it does not touch one. An accepted revision is replaced only by a
      role allowed to and only when the proposal names it; an agent may arrange
      a scene and may not change what is in it, a reviewer and a viewer may
      change nothing, and moving the history at all is its own capability. The
      stale-revision and lock refusals of the layer beneath come through as
      refusals here. Nine spec cases, including a scene taken forward two
      revisions and restored, which then plans exactly the render it planned
      before. Evidence: docs/agents/isis-3d-studio-evidence.md._

## T.15 Existing Isis dashboard: 3D creation and workspace

Dependencies: T.03–T.04, then each exposed capability; frontend-skill required.

Visual thesis: a calm Isis workspace dominated by the actual 3D asset, with a
restrained scene tree and contextual inspector. Content plan: create/import,
inspect/edit, evaluate, export; one clear primary action per state. Interaction
thesis: smooth object focus, revision comparison and timeline scrubbing, with
reduced-motion equivalents. Reuse Isis typography/navigation; no detour app,
marketing hero or dashboard-card mosaic.

- [ ] **T.15.01** Extend creation controls for text/image/multi-view/import,
      method/quality/target selection and capability-aware advanced options.
      Present cache wait, estimated cost and missing inputs before submission.
      **Verify:** component tests and Chromium Playwright cover validation,
      uploaded references and actual request bodies; unavailable modes cannot
      submit.
- [ ] **T.15.02** Build/integrate the asset viewer with orbit/pan/zoom,
      canonical views, wireframe/material/UV/LOD/collision/rig modes and
      truthful statistics. **Verify:** load real GLB fixtures, inspect actual
      scene contents, switch modes and download the correct asset; unsupported
      WebGL/device limits produce an accessible static preview fallback.
- [ ] **T.15.03** Add editable scene tree/inspector, transforms, object locking,
      material/part selection and source/variant comparison. **Verify:**
      Playwright manipulates an object, observes the resulting transform,
      reloads and undoes it; keyboard users can operate a semantic alternative
      to canvas picking.
- [ ] **T.15.04** Add rig/motion diagnostics, searchable presets, animation
      timeline, camera paths and clip/transition controls. **Verify:** real
      animation data changes on scrub/edit/save; rig errors and incompatible
      clips are visible, and manual controls remain usable without an agent.
- [ ] **T.15.05** Integrate director chat/progress with stage costs,
      cancellation, repair proposals, version comparisons and export readiness.
      **Verify:** reconnect, partial failure, cache miss, budget refusal,
      steering and restore journeys; displayed artifacts and costs come from
      persisted API results.
- [ ] **T.15.06** Add comprehensive desktop/mobile Chromium Playwright and axe
      coverage for create -> view -> edit -> rig/animate -> export, plus
      keyboard, reduced motion, short viewport and permission/error states.
      **Verify:** existing image/video/cache journeys still pass,
      memory/object-URL/GPU resources are released, and performance budgets hold
      on declared devices.

## T.16 Verified export, printing and engine integration

Dependencies: T.04/T.09 and required rig/material/motion stages.

- [x] **T.16.01** Implement real GLB/glTF, FBX, OBJ/MTL and STL exporters with a
      feature-loss matrix, correct units/axes and versioned manifests. Preserve
      blend/CAD source downloads. **Verify:** independent re-import compares
      geometry/materials/rig/clips; OBJ/STL exports cannot claim retained
      skeletal animation or full PBR, and bundle URLs name real objects. _Done
      2026-09-17. `@isis/3d-post-pipeline/delivery` holds versioned profiles for
      the five formats whose feature-loss matrix gives thirteen features a
      ceiling of kept, partial or lost with its reason, and a delivery manifest
      may claim at most that ceiling for a feature the source has and must say
      absent for one it lacks, so the schema refuses an OBJ or STL that claims
      skeletal animation or full PBR before a file is read. gltf-transform
      writes the GLB and glTF, a merged rest-pose solid the STL in millimetres
      with +Z up, and Blender 5.2.1 the FBX in centimetres and the OBJ with its
      MTL, after removing the bone-shape objects its glTF import makes, folding
      the material variants it splits off back together, saving every image as a
      file beside the model, dropping one no written file references, setting
      the scene frame rate from the source key times and clearing the pose,
      because FBX stores the current pose as each bone's local transform.
      Nothing is taken on trust: the gpu-worker delivery-export executor
      re-imports every format with the three.js loader a runtime would use and
      compares triangles, rest-pose and posed vertex clouds, attribute coverage,
      materials with their decoded texture pixels, bones, clips and morph
      targets against the source GLB read the same way, and fails the job on any
      claim it cannot observe, any reference that is not a listed file, any
      listed file nothing references, or an FBX that declares another up axis.
      The fixture passes 65 checks with its blend and STEP sources kept byte for
      byte; exporting the FBX Z-up fails on the axis declaration; all three real
      Meshy meshes pass, two of them only after the run found real defects, an
      unreferenced metallic-roughness map and a one-frame timing offset that
      clips are now compared around, and matching the frame rate is worth a
      hundred and sixty-five fold in posed deviation, measured. Against a real
      PostgreSQL and MinIO each format commits as its own artifact package and
      every part comes back through its signed GET with the hash the manifest
      lists, and the bundle rebuilt from those downloads alone verifies again.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.16.01._
- [x] **T.16.02** Add print profiles: watertightness, self-intersections, wall
      thickness, scale, tolerances, disconnected shells,
      build-volume/orientation and support/overhang guidance; export STL and 3MF
      where implemented. **Verify:** pinned open slicer import/slicing of known
      fixtures and repaired outputs; successful slicing is not a guarantee of
      physical print success. _**Done 2026-09-17.** A versioned MK4S 0.4 mm
      print profile takes its build volume, two-perimeter minimum wall and 40
      degree support threshold from PrusaSlicer 2.9.6's bundled vendor presets
      (a 0.3 mm clearance is a recorded decision). The analysis adds inward-ray
      wall thickness, clearance between separate bodies, and, for all six up
      axes, fit to the build volume and support area, with a recommended
      orientation; STL and 3MF export in millimetres, turned and on the bed.
      **Checks:** 7 fixture tests cover a T overhang, thin and thick hollow
      walls, gaps of 0.1, 1 and 3 mm, a part that fits only turned, an oversized
      cube and an open box. Four tests against the pinned PrusaSlicer 2.9.6
      agree on size, volume from STL and 3MF, manifold status, open-edge and
      part counts, supports where the analysis finds overhangs (none in the
      recommended orientation) and refusal of the oversized part. The open box
      still slices, so slicing is not validity. Three real Meshy meshes at 150
      mm were analysed and sliced. Three mutations each fail. Not claimed:
      nothing was printed; only this FDM profile is verified, not SLA; normal
      rays read thin near crossing surfaces; repaired outputs wait for T.09.02.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.16.02._
- [ ] **T.16.03** Deliver Three.js and Godot asset/scene packages with scale,
      pivots, materials, animation, LOD and collision setup. **Verify:** actual
      runtime loads, camera/animation playback, collision and texture
      correctness plus frame time/memory/draw calls on declared web/mobile
      profiles.
- [ ] **T.16.04** Add optional Unity batch import, material/normal conventions,
      prefab creation, humanoid/generic animation and test scene placement.
      **Verify:** licensed runner opens and runs the result, measures target
      performance and archives import/test logs; unavailable runner blocks only
      Unity-ready certification, never produces a simulated success.
      _2026-09-18, board tag: the "licensed runner" is the Unity Editor of
      T.19.01, which T.19.01 installs; it then needs the owner's one sign-in.
      The Unreal half of this group (T.16.05) is not affected: the executing
      machine has Unreal 5.5._ `blocked:upstream`
- [ ] **T.16.05** Add optional Unreal import, scale/pivot/material mapping,
      static/skeletal assets, LOD/collision, Blueprint placement and traversal
      test scene. **Verify:** use real UE automation/commandlets and runtime
      metrics; before declaring UE unavailable check
      `/root/workspace/UnrealEngine-5.5/Engine/Binaries/Linux/UnrealEditor-Cmd`
      and use `ueagent` when needed, as AGENTS.md requires.
- [ ] **T.16.06** Run target-specific final validation and produce an evidence
      bundle with actual import results, dependency notices, source hashes,
      profile thresholds, known losses and measured costs. **Verify:** target
      readiness derives from that exact export revision; an exported zip or
      generated README cannot substitute for engine/slicer execution.

## T.17 Benchmarks, automation and capability release gates

Dependencies: define baseline with T.00; execute incrementally for M1–M4.

- [x] **T.17.01** Create a cleared evaluation corpus spanning rigid/thin/open
      surfaces, CAD, rooms, vehicles, organic characters, multiple anatomies,
      cluttered photos, multi-view inputs, materials, edits and motion
      sequences. **Verify:** reference rights, train/test separation where
      known, fixed cameras/lighting/units and defect fixtures for each claimed
      capability. _Done 2026-09-18. A corpus has one job that matters more than
      breadth: YOU HAVE TO KNOW WHAT IS IN IT. A downloaded collection of
      "characters" gives a number nobody can interpret, because when a
      capability fails on item 47 there is no way to say whether item 47 is a
      thin surface, an open shell, or just modelled badly. So every fixture is
      built from an integer cell list written in the file by one function, every
      property is MEASURED off the result rather than declared beside it, and
      the corpus refuses to publish a fixture whose measurements contradict what
      it claims. 26 fixtures across 9 families, every family in both splits, 8
      defect fixtures: rigid-solid (3x3x3 block / stepped concave), thin-shell
      (0.5 mm slab / 0.5 mm fin), open-surface (sheet / strip), cad-through-hole
      (genus 1 / genus 2, checked by Euler characteristic), room-interior
      (inverted box / L-shaped), vehicle (chassis+4 wheels / cab over chassis),
      organic-character (biped / quadruped), multi-anatomy-rig (winged /
      serpentine), material-sample (three slots / one slot). THE CORPUS REJECTED
      ALL NINE OF MY OWN CLEAN FIXTURES ON THE FIRST RUN and was right: the
      lattice face windings were inward, so every solid measured a NEGATIVE
      volume, the room measured positive, and the inverted-volume DEFECT fixture
      measured clean; two figures also had a limb touching the torso only along
      an edge, a genuinely non-manifold surface. A second real bug: COPLANAR
      TRIANGLES BROKE THE SELF-INTERSECTION TEST — every edge-cross separating
      axis of two coplanar triangles is the shared normal, along which both
      project to one point, so the general test found no separation and called
      every pair on a flat surface an intersection, 528 OF THEM ON ONE CLEAN
      BLOCK; coplanar pairs now use the in-plane edge normals. Defect fixtures
      are the point, not an extra: one per declared kind, each naming the
      capability it tests and the detector that must see it, and each VERIFIED
      TO ACTUALLY HAVE THE DEFECT — a fixture claiming a non-manifold edge that
      measures as manifold is rejected, because a defect fixture that is
      secretly clean turns a green suite into a false report. The spec also
      checks the detectors do NOT fire on a clean fixture. A room and an
      inside-out solid MEASURE IDENTICALLY (both closed, both negative volume)
      and the corpus separates them by what they are FOR, not by a measurement,
      and says so — a real limit of orientation checking, written down. Rights
      are settled by construction and a spec asserts the code names no
      http/fetch/objaverse/shapenet/ thingiverse/sketchfab; each fixture has a
      distinct 64-bit hash and two builds are identical. Train/test splits BY
      FAMILY, not instance, so a shape and its near-twin cannot land on both
      sides. One capture spec for everything: metres, +Y up, front +Z, eight
      ring cameras at 25 degrees elevation plus a top view, 35 degree vertical
      FOV, three declared lights. **Checks:** 29 tests;
      `@isis/3d-generation-benchmarks` 87 passing across 21 files; eslint and
      the adversarial grep clean. `tsc -p tsconfig.lib.json` reports one TS6059
      rootDir error on `comparison/side-by-side-comparison-renderer.ts`
      importing `@oshun/math` — PRE-EXISTING, reproduced identically with this
      item's export line removed, and no error names a corpus file. Not claimed:
      THERE ARE NO PHOTOGRAPHS — "cluttered photos" needs real images with real
      rights and rendering a synthetic scene to call it a photo would defeat the
      purpose, so that category is reported `covered: false` with the reason
      rather than filled; motion sequences are not duplicated here (they live in
      `@isis/universal-rigging`'s preset library, which validates its own
      clips); multi-view input is a render of a fixture rather than a separate
      asset; and no renders are produced — the corpus is meshes and a capture
      spec. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.17.01._
- [ ] **T.17.02** Define per-capability quality, latency, failure-rate and cost
      thresholds before comparison. Benchmark raw generators, processed outputs,
      local director, optional Astra and licensed/user-provided Meshy/Higgsfield
      references under matched inputs/effort. **Verify:** blinded review plus
      objective metrics, retained failures and sample counts; no SOTA/parity
      score is inferred from demos, CAD scores or subjective aggregate ratings.
      _DEFINING HALF DONE 2026-09-18; the benchmarking half stays open until a
      generator clears admission to benchmark. Left unchecked on purpose: the
      item asks for measurements this box cannot take.
      `libs/isis/3d-generation-benchmarks/src/thresholds/capability-thresholds.ts`
      declares thresholds for seven capabilities — image-to-3d, text-to-3d,
      texturing, rigging, text-to-motion, retopology, scene assembly — each with
      quality metrics and their DIRECTION, p50/p95 latency, max failure rate,
      max cost per sample and a minimum sample count, and each quality number
      with a rationale (the spec requires over forty characters: a number
      without a reason is a guess with a decimal point). Generated and preset
      motion are held to the SAME foot-slide number, 0.06 m. A threshold chosen
      after seeing the results is not a threshold but a description, so every
      one carries the instant it was declared (2026-09-18T00:00:00Z, "before any
      admitted generator exists to measure") and `judgeLocal3DCapabilityRun`
      REFUSES TO JUDGE A RUN THAT STARTED BEFORE ITS OWN THRESHOLD WAS WRITTEN —
      `threshold-postdates-run`, an ordering a machine can check and a memory
      cannot. Three things make a comparison valid and all three are enforced:
      MATCHED INPUTS (different fixture sets means they were not compared —
      refused, not caveated), RETAINED FAILURES (attempts must equal successes
      plus failures, and a run reporting failures without keeping their ids is
      refused: "counting a failure is not retaining it; the ids are what lets
      somebody go and look"), and ENOUGH SAMPLES (below the minimum the outcome
      is `insufficient-samples`, explicitly neither a pass nor a fail — "a
      number too small to be either" — and a metric computed over fewer samples
      than the run claims is rejected separately). PARITY IS A CLAIM WITH
      REQUIREMENTS, NOT A SUMMARY: there is no function returning an overall
      score (`producesAnOverallScore` is false) because an overall score is how
      a weak capability gets carried by a strong one; a claim is per capability
      and needs the SAME objective metrics on both sides (a metric missing from
      one side is refused — "not whichever each happened to report"), matched
      fixtures, matched declared effort and both runs judgeable.
      `refuseLocal3DParityFromSubjectiveAggregate` refuses a demo ("a sample
      chosen by the person making the claim"), a subjective aggregate, a score
      on another task and a CAD benchmark ("exact surfaces from exact input,
      which is not what a generator is doing"), each with its own explanation
      and each ending with what it would take instead. BLINDED REVIEW SUPPORTS
      AND NEVER DECIDES: a blinded review is attached as supporting evidence and
      the claim says "the objective metrics decide"; a review run with the
      labels VISIBLE is refused outright rather than discounted, because a
      preference for a name is not a preference for an output; and a
      95%-preference blinded review does not turn a losing objective comparison
      into a win. **Checks:** 28 tests; `@isis/3d-generation-benchmarks` 115
      passing across 22 files, up from 87/21; eslint and the adversarial grep
      clean. Not claimed: NOTHING HAS BEEN BENCHMARKED — the thresholds have
      judged nothing, which is the only moment at which they can honestly be
      set; the numbers are judgements with reasons, written down so they can be
      argued with before a result exists to argue about; and metric names are a
      contract, not an implementation — this file compares what it is given and
      measures no geometry itself. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.17.02._ _2026-09-18, reconciled
      with T.01.15 and T.01.05: the "Meshy/Higgsfield references" arm in the
      first sentence cannot run as written. T.01.15 (checked 2026-09-15, owner
      decision) removed Meshy from every benchmark input because its terms
      forbid competitive analysis, and `competitive-analysis-exclusions.spec.ts`
      fails the build if it returns; T.01.05 refused Higgsfield reference
      outputs for unreadable terms. Until written permission or readable terms
      exist, the comparison set is the raw generators, processed outputs, the
      local director and optional Astra, and T.17.06 can claim no Meshy or
      Higgsfield parity in either direction._
- [ ] **T.17.03** Run all applicable targeted automation: lint, TS/Python
      checks, unit/service/integration, schemas/migrations/OpenAPI drift, worker
      builds, security, deterministic geometry, accessibility and Chromium e2e.
      Extend existing k6/API and viewer performance avenues where affected.
      **Verify:** passing logs for the actual changed scope; follow AGENTS.md
      resource checks and serial expensive runs, not full-workspace sweeps.
- [ ] **T.17.04** Execute live proof for every admitted model/mode/profile and
      composed milestone flow, including cold/warm, retry, cancel, partial
      result and budget failure. **Verify:** real parseable/downloadable assets,
      independent re-import and measured provider/worker receipts; fixtures and
      mocks stay labelled offline proof, never live completion.
- [ ] **T.17.05** Measure queue-to-download p50/p95, peak memory, success rate,
      GPU/CPU/controller/storage/transfer costs and repair rounds. Calculate
      cost per accepted finished asset including failed attempts and appropriate
      fixed-cost allocation. **Verify:** raw measurements, rate
      date/currency/SKU and sample size support every figure; small samples are
      labelled and upstream/sticker estimates cannot replace end-to-end
      observations.
- [ ] **T.17.06** Publish the capability/profile acceptance matrix below with
      evidence, limitations and unresolved gaps. Gate release on deterministic
      requirements plus calibrated visual/art review where appropriate.
      **Verify:** all required cells pass for the named release scope; rejected
      optional providers do not conceal a missing capability or justify claiming
      full Meshy/Higgsfield parity.

| Requested capability                       | Implementation tasks   | Required evidence                                                                                        |
| ------------------------------------------ | ---------------------- | -------------------------------------------------------------------------------------------------------- |
| Image/text/multi-image -> 3D               | T.05, T.07             | Real assets; reference/held-out-view comparisons; native versus composed modes explicit.                 |
| Procedural/CAD and hybrid assemblies       | T.06                   | Executable editable source, analytical geometry/dimensions and component-preserving edits.               |
| Real-photo and multi-object reconstruction | T.07                   | Object/layout/scale evidence; inferred regions; custom-license and open profiles separate.               |
| PBR/text/image retexturing                 | T.10                   | Actual channels, mesh preservation, seam/lighting tests and cross-renderer appearance.                   |
| Smart-topology-class usability             | T.09, T.11             | Target budgets, silhouette/UV/deformation evidence; artist-quality topology remains a separate claim.    |
| Auto-rigging and skin weights              | T.11                   | Hierarchy, normalized weights, diagnostic poses and supported anatomy matrix.                            |
| Text animation/presets/retargeting         | T.12, T.13             | Real cleared clips, semantic sequence fidelity, contacts, transitions and deformation metrics.           |
| Agent/closed-loop/selective edits          | T.08, T.14             | Budget-bounded improvements, preserved locked assets, rollback and no-controller/local/hosted ablations. |
| Scene/workspace/timeline/API               | T.03, T.04, T.14, T.15 | Persisted edits, roles, camera/animation playback, revision restore and full browser/API journeys.       |
| Mesh/CAD/print exports                     | T.16.01, T.16.02       | Real format-specific re-import/slicing, loss disclosures and source artifacts.                           |
| Three.js/Godot/Unity/Unreal                | T.16.03–T.16.06        | Actual engine runtime and performance evidence per target; optional proprietary tools separated.         |
| Self-hosting, reliability and economics    | T.01–T.03, T.17, T.18  | Hosted APIs disabled for open-profile proof, recovery tests and measured cost per accepted asset.        |

## T.18 Operations, rollout and ongoing model review

Dependencies: passing T.17 gates for the release scope.

- [ ] **T.18.01** Ship staged capability flags and rollback by worker/model/
      profile version, preserving existing image/video endpoints and accepted
      artifacts. **Verify:** canary deployment and rollback with active jobs,
      migrations and queued revisions; no orphaned spend or unreadable outputs.
- [ ] **T.18.02** Add runbooks/alerts for endpoint placement, queue stalls, CUDA
      incompatibility, OOM, cache thrash, storage growth, bad assets, controller
      loops and unexpected costs. **Verify:** injected failures trigger
      actionable alerts and bounded recovery; document operator commands and
      metric provenance without exposing credentials.
- [ ] **T.18.03** Implement tested recovery/backup/restore, asset retention and
      model availability handling across library, cache, projects and revisions.
      **Verify:** worker/API restart, corrupt cached file, failed upload and
      lost temporary volume recover from authoritative data without rerunning
      accepted stages unnecessarily or deleting referenced source assets.
- [ ] **T.18.04** Extend existing upstream-change monitoring with scheduled
      release/license/security/cost reviews and benchmark-based promotion.
      **Verify:** a changed checkpoint/license produces a review record and
      admission/requalification work, not an automatic production swap. No
      background monitoring is claimed active until configured and proven.
- [ ] **T.18.05** Finalize developer/operator/user documentation, API examples,
      supported-mode limits and a truthful capability comparison. Record
      remaining topology/anatomy/reconstruction gaps and follow-up owners.
      **Verify:** the documented first-run journey works, release evidence
      matches the shipped profile, and relevant changes are committed and
      present on `origin/main`.

## Unity and Blender agent tool review (2026-09-13)

### Recommended approach and what is actually confirmed

**Use Unity's official CLI/Pipeline as the default Unity agent interface; use
Blender's Python API as the execution foundation, with official Blender Lab MCP
for live sessions and headless Python for production jobs.** This is the
recommended architecture based on the sources below, not a claim that a local
head-to-head benchmark has already proved a universal winner. T.21 makes
effectiveness measurable. MCP supplies a tool transport; it does not inherently
improve geometry, provide a sandbox or make arbitrary scripts reproducible.

Unity explicitly recommends direct CLI commands for shell-capable agents and
says they have lower latency/token overhead than MCP. Its deprecated component
is the MCP server inside `com.unity.ai.assistant`, **not** `unity mcp`, which
remains supported. Adopt the latter for MCP-only clients and keep one common
command implementation behind both routes. The CLI is free and does not require
a Unity AI subscription; Unity Editor licensing still applies.
[Unity migration guidance](https://docs.unity.com/en-us/unity-cli/replace-mcp-server-unity-cli).

The official Pipeline package connects a Unity 6.0-or-newer Editor to a local
HTTP command surface. It is separate from installing the CLI binary. Explicit
project targeting matters when several Editors are running.
[Pipeline setup](https://docs.unity.com/en-us/unity-production-pipeline/local-tools-cli/unity-pipeline-package).
The CLI reference still labels the tool experimental and tells users to treat
the installed `unity --help` as authoritative. Pin and discover versions rather
than coding against a launch post. Structured output, command discovery and
build/test commands are the useful automation primitives.
[CLI reference](https://docs.unity.com/en-us/unity-cli/unity-cli-reference). The
native batch fallback invokes the pinned **Editor executable**, whose
`-batchmode`/`-executeMethod` arguments differ from the new `unity` CLI
commands.
[Editor command-line reference](https://docs.unity3d.com/6000.0/Documentation/Manual/EditorCommandLineArguments.html).

Blender's own Lab page now provides an MCP integration requiring **Blender
5.1+**, an add-on, MCP server and compatible client. It explicitly warns that
generated code executes without protective guards. Use isolated sessions and
existing T.03 controls; selecting an official implementation does not remove
that requirement. [Blender Lab MCP](https://www.blender.org/lab/mcp-server/).
The landing page was retrieved in this review; the linked project source could
not be retrieved, so source/license/transport inspection remains T.20.01's
admission gate. No undocumented screenshot, undo or job API is assumed present.

For repeatable work, Blender documents background execution and Python scripts,
including `--python-exit-code` and argument-order effects. These support a
worker contract with files, logs, failures and actual output checks.
[Blender command-line manual](https://docs.blender.org/manual/en/4.5/advanced/command_line/arguments.html).
Its Python API is not thread-safe; bridge commands must serialize Blender API
access, with concurrency in independent worker processes rather than concurrent
`bpy` calls.
[Blender threading guidance](https://docs.blender.org/api/current/info_gotchas_threading.html).

### Route selection

| Use case                                                                | Default route                                                           | Alternative and decision rule                                                                                                   |
| ----------------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Unity installation, project discovery, builds and tests                 | Official Unity CLI; existing license/account, pinned Editor and modules | Native Editor batch mode for a proven compatibility need or CLI regression; do not create a second project-management system.   |
| Unity scene/assets/Play-mode inspection and edits                       | Official CLI + `com.unity.pipeline`, using typed registered commands    | Official `unity mcp` exposes that same bridge when the agent requires MCP.                                                      |
| Unity one-off diagnosis                                                 | Bounded live C# evaluation in an isolated project                       | Promote repeated operations to tested registered commands; generated eval code is not itself a durable project change.          |
| Blender live scene/material/rig inspection and iterative artist changes | Official Blender Lab MCP on a qualified 5.1+ session                    | Community MCP only for a measured compatibility/capability advantage, or Python worker snapshots if live access is unnecessary. |
| Blender procedural assets, cleanup, UV/bake, rigs, rendering and export | Versioned Python scripts in Blender background workers                  | Reuse the same operation functions through live MCP; do not replay a long series of UI clicks for batch work.                   |
| Visual evidence                                                         | Actual camera renders/runtime captures plus structured scene metrics    | Viewport screenshots supplement evidence; camera, render settings and dependency-graph state must be recorded.                  |
| An operation available only through the application UI                  | Narrow computer-use fallback with before/after inspection               | Record why API/CLI access is insufficient and convert recurring steps into supported automation where possible.                 |

The established community alternatives remain useful comparison candidates:

- [ahujasid/blender-mcp](https://github.com/ahujasid/blender-mcp) explicitly
  identifies itself as third-party and documents scene tools, arbitrary Python
  and external asset/generation integrations. Its telemetry is opt-out by
  default. Do not confuse its `blender-mcp` package with the Blender Lab server.
  If selected, disable telemetry and unauthorised external services, including
  Hunyuan/paid generation, under the existing open-core policy.
- [CoplayDev/unity-mcp](https://github.com/CoplayDev/unity-mcp) is an MIT
  community bridge with focused scene/asset/script/test tools and advertised
  support for older Unity versions. Evaluate it for an older project or a
  demonstrated command gap. Do not install it alongside another active writer to
  the same Editor by default.

Official Unity engineering skills are available from
[Unity-Technologies/skills](https://github.com/Unity-Technologies/skills/blob/main/skills/unity-cli/SKILL.md).
The binary also distributes version-matched skill guidance. Review and pin the
relevant skills for each supported agent; a skill is operating guidance, not the
executable connection or permission to upgrade a project.
[Unity CLI release notes](https://docs.unity.com/en-us/unity-cli/release-notes)
also document detached jobs and evolving command behavior. In particular, new
project creation may enable cloud integration by default; the existing
no-new-account/local-first decision requires an explicit local configuration.

### Execution contract and integration boundaries

Keep T.08's provider-independent tools as the public agent contract. Route them
to a session bridge or a background worker according to whether the operation
needs live state, graphics or a fresh deterministic process. A proposed common
envelope carries project/session ID, expected revision, operation/argument
schema version, toolchain versions, budget/deadline and idempotency key. Results
carry actual state changes, logs, evidence artifact IDs and persisted revision.

Use targeted scene queries and compact structured responses, not a dump of the
entire project or mesh on each call. Discover the relevant command/tool schema
once per pinned session, then invalidate it on toolchain upgrade or Unity domain
reload. Render and inspect after meaningful edits. Keep save/reopen verification
separate from a tool's success message: live modifications can be temporary.

Prefer high-level, validated operations for routine tasks, with constrained
Python/C# scripts as an explicit advanced route. JSON input is parsed as data;
never concatenate user descriptions into source or shell commands. Arbitrary
eval remains arbitrary code despite a typed wrapper, so process isolation and
restricted filesystem/network access are the actual containment boundary.

A live Blender or Unity session has one mutation lease. Parallel critics may
inspect immutable snapshots; parallel builders use separate sessions/project
copies and revision-checked merging. Unity recompilation, asset imports and
Play-mode transitions require explicit readiness states. Blender selection, mode
and dependency-graph evaluation require explicit context. Neither bridge gets to
bypass the existing cost, content-policy, artifact or provenance gates.

Reuse `libs/isis/3d-post-pipeline/src/export/blend-export.ts` and
`libs/isis/3d-post-pipeline/src/export/unity-package-export.ts` after T.00's
runtime audit, and integrate transport adapters through T.02/T.08 rather than
creating another asset or job registry. Existing Blender export test fixtures
mention 4.2; that does not meet Lab MCP's 5.1 minimum. Qualify separate
headless/live versions or migrate with round-trip proof. Never silently reopen
and overwrite an artist's file in a newer DCC or upgrade an existing Unity
project just to make a bridge connect.

No software is installed and no live agent/tool benchmark is claimed by this
planning update. T.19–T.21 below are the implementation and qualification work.

## T.19 Unity CLI, Pipeline and optional MCP transport

Dependencies: T.01 tool/license admission, T.02/T.03 worker contracts and
T.04/T.08 revision/tool interfaces. Extends T.16.04; Unity remains optional.

- [ ] **T.19.01** Record and pin official CLI, compatible Unity Editor/modules,
      `com.unity.pipeline`, license requirements and command schemas. Discover
      installed tools/projects before installation; use existing accounts and
      explicit local-only project configuration. **Verify:** version/health/
      entitlement probes and repeatable setup; no silent Editor upgrade, cloud
      project creation or Unity AI subscription dependency. _PIN, SURFACE AND
      DISCOVERY DONE 2026-09-18; two blockers are the vendor's. THERE IS NO
      STABLE UNITY CLI: the installer reads `latest.json` when
      `UNITY_CLI_CHANNEL` is empty and that URL answers 404; only
      `latest-beta.json` exists, at 1.0.0-beta.10, which is why Unity's own
      one-liner sets the beta channel and why the reference says experimental
      twice. THE DOCUMENTED INSTALL IS UNPINNED AND A PINNED ONE EXISTS: reading
      the 637-line script, it honours `UNITY_CLI_VERSION` and verifies the
      download against a per-platform sha256 from the manifest, so
      `UNITY_CLI_VERSION=1.0.0-beta.10 UNITY_CLI_CHANNEL=beta` is exact — the
      `unity-cli` row moved from `unselected` to a `release-archive` pin with
      four binary digests and no longer raises `pin_floating`. SURFACE RECORDED:
      every command group, the five output formats and their
      `{success, command, data, errors, warnings}` envelope, the ten exit codes
      AND UNITY'S OWN RETRY RULE (only 6 and 7, never 8), and the environment
      variables. THE THREE THINGS THE ITEM FORBIDS ARE ENFORCED, NOT DESCRIBED:
      `classifyUnityCommand` decides before an argv runs whether it mutates or
      touches the cloud, and the spec asserts EVERY PROBE DISCOVERY RUNS IS
      NON-MUTATING. DISCOVERY RAN HERE AND FOUND NOTHING — no `unity`, no Hub,
      no Editor, no Unreal at the path AGENTS.md names, no Godot — and the live
      case asserts there is no third state where the pin stands in for a
      measurement. LEFT UNCHECKED FOR THREE THINGS: the CLI binary's own licence
      is published nowhere and ships only inside the binary;
      `com.unity.pipeline` has no published version and no published licence,
      because `unity pipeline install` requires `unity auth login` first; and
      repeatable setup is recorded but cannot be EXECUTED without an entitlement
      and an account, which is what T.16.04 means by an unavailable runner
      blocking certification rather than producing a simulated success. 16 tests
      pass. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.19.01._
      _2026-09-18, owner instruction ("try to install what it needs … rather
      than just saying the env is not setup"): **this item is actionable and is
      not parked.** Discovery found no Unity on either machine; the next step is
      to install it, not to report that. On the executing machine: install Unity
      Hub and one pinned LTS Editor with the Linux build support module, and the
      Unity CLI at `UNITY_CLI_VERSION=1.0.0-beta.10 UNITY_CLI_CHANNEL=beta` (the
      pinned install this note already verified), recording the exact commands,
      versions and checksums. Only two narrow steps are not an agent's: signing
      in (`unity auth login`, the owner's Unity account — Unity Personal costs
      nothing) and the still-unpublished licence text of the CLI binary and of
      `com.unity.pipeline`. Do everything up to the sign-in, record the attempt,
      and ask the owner for that one act; park nothing else._
- [ ] **T.19.02** Integrate session discovery and explicit project-path/PID
      binding, readiness, one-writer leases and CLI structured-output parsing.
      **Verify:** with two Editors open, commands affect only the selected
      project; stale sessions, import/compile failures, stderr noise and
      schema/version drift cannot be interpreted as successful tool results.
      _2026-09-18, board tag: needs the Unity Editor that T.19.01 installs and
      the owner's one sign-in; remove this tag as soon as T.19.01 records a
      working Editor._ `blocked:upstream`
- [ ] **T.19.03** Implement tested registered commands for hierarchy/components,
      actual asset import, materials, prefabs, transforms, scene placement,
      animation, collision and captured runtime evidence. **Verify:** domain
      assertions against real Unity objects plus save/reopen persistence; stable
      asset GUIDs and `.meta` files survive repeated idempotent operations.
      _2026-09-18, board tag: needs the Unity Editor that T.19.01 installs and
      the owner's one sign-in; remove this tag as soon as T.19.01 records a
      working Editor._ `blocked:upstream`
- [ ] **T.19.04** Add constrained C# evaluation for diagnosis/prototyping,
      loading source from reviewed files and logging hashes/results. Promote
      repeated workflows into registered commands. **Verify:** wrong-project,
      stale-revision, forbidden I/O and timeout cases; a temporary eval fix is
      persisted through an actual asset/script change and then revalidated.
      _2026-09-18, board tag: needs the Unity Editor that T.19.01 installs and
      the owner's one sign-in; remove this tag as soon as T.19.01 records a
      working Editor._ `blocked:upstream`
- [ ] **T.19.05** Offer official `unity mcp` as an alternative transport to the
      same operation set; scope configuration to the intended agent/project.
      Review/version relevant Unity CLI and engineering skills. **Verify:**
      direct CLI and MCP operations produce equivalent scene state and errors;
      unrelated client configuration is preserved and the deprecated
      `com.unity.ai.assistant` MCP server is not required or double-connected.
      _2026-09-18, board tag: needs the Unity Editor that T.19.01 installs and
      the owner's one sign-in; remove this tag as soon as T.19.01 records a
      working Editor._ `blocked:upstream`
- [ ] **T.19.06** Wire supported detached command jobs to Isis stage IDs,
      progress, cancellation and deadlines. Handle asset imports, compile/domain
      reload and Play-mode transitions before continuing. **Verify:** reconnect,
      lost response and cancellation do not repeat mutations; command completion
      waits for the observed Editor state and saved artifact rather than a
      timer. _2026-09-18, board tag: needs the Unity Editor that T.19.01
      installs and the owner's one sign-in; remove this tag as soon as T.19.01
      records a working Editor._ `blocked:upstream`
- [ ] **T.19.07** Run EditMode/PlayMode tests, headless builds and a graphics-
      enabled runtime verification scene through qualified CLI commands. Retain
      native Editor `-batchmode`/`-executeMethod` fallback where justified.
      **Verify:** real reports/artifacts and injected compile/test/build
      failures; no second process opens a locked project and no `-nographics`
      run is misrepresented as visual/material validation. _2026-09-18, board
      tag: needs the Unity Editor that T.19.01 installs and the owner's one
      sign-in; remove this tag as soon as T.19.01 records a working Editor._
      `blocked:upstream`
- [ ] **T.19.08** Evaluate CoplayDev's community bridge only against a recorded
      older-Editor or missing-command requirement. Qualify any selected fallback
      with pinned code/dependencies and the same operation/security tests.
      **Verify:** a documented compatibility/coverage advantage, single-writer
      routing, shutdown/reconnect and rollback; adopting it does not replace
      engine execution evidence with a successful MCP response. _2026-09-18,
      board tag: needs the Unity Editor that T.19.01 installs and the owner's
      one sign-in; remove this tag as soon as T.19.01 records a working Editor._
      `blocked:upstream`

## T.20 Blender Lab MCP and reusable headless Python operations

Dependencies: T.01–T.04 and T.08 tool contracts; extends T.06/T.09–T.14/T.16.

- [x] **T.20.01** Audit and pin Blender Lab's actual server/add-on release,
      source/licenses, dependencies and exposed tools; qualify Blender 5.1+
      compatibility and distinguish the community package explicitly. Inventory
      current headless Blender versions and file formats. **Verify:** matching
      server/add-on handshake and real session capabilities; unresolved source
      admission or version incompatibility remains a visible blocker. _AUDIT,
      HANDSHAKE AND MANIFEST PIN DONE 2026-09-18. THE 2026-09-13 BLOCKER IS DEAD
      — "the linked project source could not be retrieved" — the source, both
      release artifacts and a live handshake are recorded.
      `projects.blender.org/lab/blender_mcp` answers 403 to an anonymous browser
      but the Gitea API does not and the release assets download without a
      login. v1.0.3, published 2026-09-11: `mcp-1.0.3.zip` (the add-on, 17,975
      bytes, sha256 `a7a9da81…`) and `blender-1.0.3.mcpb` (the server, 5,500,672
      bytes, `d6fe04dd…`). Add-on: id `mcp`, `blender_version_min = "5.1.0"`,
      `SPDX:GPL-3.0-or-later`, declared `network` permission for a local TCP
      socket, nine Python files. Server: `uv run blender-mcp`, python >= 3.10,
      dependencies `docutils`, `mcp[cli]>=1.2.0,<2`, `pyyaml`, GPL-3.0-or-later.
      THE HANDSHAKE RAN ON THIS BOX: the add-on unpacked into a temporary
      `BLENDER_USER_RESOURCES`, enabled as `bl_ext.user_default.mcp` with
      `use_online_access` on, served by
      `blender --background --command blender_mcp`, answering a
      null-byte-delimited JSON request `{"type":"execute","code":…}` on a raw
      TCP socket (NOT stdio) with
      `{"status":"ok","result":{"version":[5,2,1],…}}`, and an unknown type with
      a named error. THE FINDING THAT MATTERS: THE BLENDER SIDE HAS NO TOOL
      SURFACE AT ALL — one request type whose payload is ARBITRARY PYTHON. The
      20 tools live in the MCP server and each is a Python string it sends down
      that socket. THERE IS NO UNDO TOOL AND NO JOB API, which the review said
      not to assume; there ARE screenshots, which it also said not to assume. A
      bridge whose only input is Python cannot refuse a URL or a shell string
      the way T.08.02's typed tools do, because everything it takes is a string
      of Python. "WEAK SANDBOX" IS THE FILE'S OWN WORD and it is accurate: it
      overrides `sys.exit` and blocks a few operators, and measured through the
      live bridge as the user Blender runs as, `open('/etc/hostname')`,
      `subprocess.run(['id','-u'])` returning uid 0, and an outbound connection
      to 1.1.1.1:53 ALL SUCCEEDED. So the Lab MCP may only run inside T.03.06's
      sandbox and T.20.03's isolation, never beside them. BACKGROUND MODE
      RESTRICTS THE TOOL SET by construction — the screenshot tools call
      `bpy.ops.screen.screenshot` and the viewport render needs a viewport,
      neither of which exists under `--background`, and `cli.py` says deferred
      responses are unsupported there. HEADLESS INVENTORY (5.2.1 LTS): importers
      `alembic`, `obj`, `ply`, `stl`, `usd`, `import_scene.fbx`,
      `import_scene.gltf`; exporters the same five plus `export_scene.fbx` and
      `export_scene.gltf`. THE MANIFEST PIN IS DONE (2026-09-18): the single
      `blender-lab-mcp` row is gone and there are two, `blender-lab-mcp-addon`
      (`mcp-1.0.3.zip`, sha256 `a7a9da81…`) and `blender-lab-mcp-server`
      (`blender-1.0.3.mcpb`, `d6fe04dd…`), both `release-archive` pins on bytes
      downloaded and hashed on the box that ran the handshake. The add-on's
      closure is `none` and true — nine files importing the standard library and
      `bpy` only — so the row PASSES, the first agent-transport row that does.
      The server's closure was RESOLVED, not guessed: the project ships no lock
      file, so a resolve on 2026-09-18 (pip 24.0, CPython 3.12.3) produced 38
      packages with each licence read from the installed distribution metadata,
      and the check now refuses the row on a named package instead of on nobody
      having looked —
      `certifi@2026.7.22 is weak-copyleft (MPL-2.0) and no row with recorded     obligations covers it`.
      `docutils` needed a vocabulary fix rather than an exception: its shipped
      wheel is a public-domain dedication plus BSD-2-Clause exceptions (the one
      GPL file, `tools/editors/emacs/rst.el`, is not in the wheel), so its
      expression is `CC-PDDC AND BSD-2-Clause` and `CC-PDDC` joined
      `PERMISSIVE_SPDX`. THE BLENDER ROW NOW STATES THE INCOMPATIBILITY — 5.1.0
      minimum against a 4.0.2 image pin — and carries the 5.2.1 headless
      importer/exporter inventory. A CORRECTION TO THE 2026-09-18 NOTE ABOVE: it
      is not true that every other row carries a `textSha256`; 23 of the 61 rows
      have none, `bpy` (GPL-3.0) among them, so these two are not the first
      unhashed rows, only the first where no text exists to hash. OWNER DECISION
      2026-09-18: an SPDX identifier on every file plus the package manifests is
      the grant, so such a row records `licenceEvidence.textSha256` as `null`
      explicitly and is admitted on the licence map's recorded obligations; the
      decision is a note in the manifest. Overall verdict unchanged at fail,
      22/61 rows passing (was 21/60). 43 tests pass, `--check` exits 0.
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.20.01 (both
      sections)._
- [x] **T.20.02** Refactor/reuse real Blender operations into versioned Python
      modules shared by headless and live routes: structured inspect, generate,
      transform, mesh/UV/material/rig/motion processing and export. Prefer
      direct data/mesh APIs and validated Geometry Nodes where appropriate;
      specify context for UI-dependent operators. **Verify:** known-geometry
      fixtures give equivalent results regardless of prior selection, mode or
      workspace. _Done 2026-09-18 against REAL Blender 5.2.1. `bpy.ops.*` IS THE
      UI'S ENTRY POINT and it reads the UI's state — the active object, the
      selection, the mode, the area under the cursor — so the same call does
      different things, or raises "poll() failed, context is incorrect",
      depending on what happened before it; in a pipeline that is whatever the
      previous job left behind. Twelve versioned modules work on
      `bpy.types.Mesh`, `bmesh`, `matrix_world`, `node_tree`, `edit_bones`,
      action channelbags and `vertex_groups` instead, name their subject, and
      REFUSE A NAME THAT IS NOT THERE rather than falling back to whatever is
      active. THE GUARANTEE IS TESTED, NOT ASSERTED: `context.disturb` is an
      operation IN THE PACKAGE (not a helper in the spec, so there is one body
      of Python) that leaves exactly the state a half-finished job leaves — a
      decoy created, selected, active, in EDIT mode, in a new active collection
      — and every operation runs twice, clean and disturbed, with the results
      compared. Generate, transform, mesh, both UV modes, material, rig, motion
      keyframe and motion sample return identical results either way, and
      generate→UV→material→export gives a BYTE-IDENTICAL GLB by sha256 from
      both. FOUR REAL DEFECTS the fixture found, all silent: (1)
      `bpy.ops.mesh.select_all` CANNOT POLL in `--background` — no windows means
      no area and no region and `temp_override` cannot invent them — so the UV
      path writes the selection at the DATA level first; (2) `temp_override`
      DOES NOT SATISFY `mode_set`, measured: overriding object, active_object
      and selected_objects left the armature in OBJECT mode and `edit_bones.new`
      raised, because mode_set reads the VIEW LAYER's active object, so
      `common.active_only` WRITES the active object and selection and puts both
      back; (3) `Action.fcurves` DOES NOT EXIST in 5.2 — slotted actions arrived
      in 4.4 and the curves live under layers→strips→channelbag(slot), read
      through one call that still works on 4.x; (4) `remove_doubles` carries no
      count to read, so merged vertices are measured before and after. TWO
      OPERATIONS ARE OPERATOR-BACKED AND SAY SO — glTF export and smart-project,
      both writing the selection from the payload and restoring it — and a spec
      strips docstrings and asserts the modules containing a real `bpy.ops.x.y(`
      call are EXACTLY the ones that declare it, so a new operator call cannot
      be added without the registry saying so; another asserts no module reads
      `bpy.context.active_object` or `.selected_objects` at all. The
      dispatcher's JSON result carries the package version (a mismatch is
      refused), the per-step results, and on failure a code and traceback: a
      missing subject is `object_missing` naming it with the steps that did run
      and exit 1, an unknown operation is named rather than skipped. **Checks:**
      17 tests, and 47 across `src/blender` with T.20.03's 30; the first run was
      6 failures, which are the four defects above. Targeted tsc, eslint,
      prettier and the adversarial grep clean. Not claimed: NO GEOMETRY NODES —
      nothing needed a node tree a bmesh call did not do more directly, and
      adding one to have one would be a node tree nothing validates; NO LIVE
      ROUTE EXISTS to share this with (T.20.04), so "shared" is a property of
      the design rather than an observed second caller; NOTHING WAS MIGRATED
      onto it, so `blend-export.ts`, the gpu-worker render executor, the
      thumbnail renderer and the turntable preview still carry their own
      scripts; and the operation set is the ITEM'S list, not Blender's —
      modifiers, sculpting, particles, physics and compositing are absent and no
      module pretends to them. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.02._
- [x] **T.20.03** Implement a background runner with explicit binary/version,
      isolated configuration, input files, ordered arguments, nonzero Python
      error exits, bounded logs/time/memory and actual artifact parsing. Disable
      imported-file auto-execution; use process/network isolation for generated
      scripts. **Verify:** script failure, missing output, timeout and corrupt
      blend/texture inputs fail loudly; repeated jobs preserve
      geometry/materials and do not depend on an interactive desktop or a
      preexisting MCP server. _Done 2026-09-18 against REAL Blender 5.2.1 LTS on
      the Linux dev server. Blender is a desktop application that can be told to
      behave like a batch tool and every default that matters is wrong for that.
      A FAILING SCRIPT STILL EXITS 0 — measured, not quoted: the same
      `raise RuntimeError` exits 47 through the runner and 0 through
      `blender --background --factory-startup --disable-autoexec --python x.py`,
      so `--python-exit-code` is on every run and is not a parameter. THE HOST'S
      CONFIGURATION LOADS unless stopped: `--factory-startup` plus
      `BLENDER_USER_RESOURCES` at a directory the runner made, checked FROM
      INSIDE Blender (`bpy.utils.resource_path('USER')` comes back under the
      temp dir), so "it worked on the box that had the add-on" cannot happen. A
      .BLEND CAN RUN PYTHON WHEN OPENED — a feature for a rigger and an RCE hole
      for a service opening uploads — so `--disable-autoexec` is on every run.
      AN ARTIFACT THAT EXISTS IS NOT ONE THAT PARSED: a GLB's declared length
      against the real length and its JSON chunk against the end of file, a
      PNG's signature and IHDR dimensions, a .blend's header or zstd/gzip
      container, JSON through `JSON.parse` — `b'glTF'` plus forty zero bytes
      passes every existence and size check and is answered `output_unparsable`.
      ARGUMENT ORDER is stated once because getting it wrong does not error:
      Blender silently treats a misplaced flag as a file to open. THE BOUNDS ARE
      REAL: SIGTERM at the deadline then SIGKILL (120 s sleep under a 4 s
      timeout returns in under a minute); peak RSS sampled from
      `/proc/<pid>/status` every 100 ms — `RLIMIT_AS` was REJECTED because
      Blender maps far more address space than it uses and a limit low enough to
      bound anything stops it starting; logs capped by bytes with the overflow
      counted (20 MB of prints under a 4 KiB cap gives 4 KiB and over a million
      dropped bytes). A GENERATED SCRIPT RUNS WITH NO NETWORK under
      `unshare -n`, proved with the SAME script both ways —
      `socket.create_connection` to 1.1.1.1:53 reports `reached:false` isolated
      and `reached:true` not. A corrupt `.blend` and a corrupt PNG are both
      refused BEFORE a process starts (`exitCode` null). The same cube export
      twice is byte-identical by sha256, with `DISPLAY` unset and no MCP server
      anywhere. There is NO PATH LOOKUP — "whichever blender" is not a version —
      and a binary whose major/minor differs from the run's requirement is
      refused. The binary itself was installed from the publisher's archive with
      its sha256 `a31f524f…` VERIFIED against `blender-5.2.1.sha256`, which is
      the checked download T.01.04 records as missing everywhere else.
      **Checks:** 29 tests, passing first run; without `OSHUN_BLENDER_BIN` the
      13 pure ones run and the 16 real ones skip. The library suite is 194
      passing, 18 skipped, and 12 spec FILES that do not load —
      `Cannot find package 'zod'/'three'/     'meshoptimizer'`, PRE-EXISTING to
      this worktree's node_modules, zero tests failed, no error naming a file of
      this item's. Targeted tsc, eslint, prettier and the adversarial grep
      clean. Not claimed: the tools manifest still pins Blender 4.0.2 and this
      ran against 5.2.1 — reconciling the pin and qualifying 5.1+ is T.20.01's,
      and this is an inventory data point for it; NOTHING WAS MIGRATED onto the
      runner, so `blend-export.ts`, the gpu-worker render executor, the
      thumbnail renderer and the turntable preview still spawn Blender their own
      way (several by PATH lookup) and rewiring them belongs with T.20.02; the
      `isolation_unavailable` branch has not been exercised on a host that
      refuses a namespace; and memory is peak RSS rather than a cgroup, so a
      child that spikes and dies between two samples is not caught. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.03._
- [x] **T.20.04** Connect official Lab MCP to isolated live sessions through
      T.08's typed operations, with project/scene identity, revision checks and
      serialized Blender API execution. Discover supported inspection/render
      tools instead of inventing method names. **Verify:** real scene edit and
      readback, two-session isolation, main-thread handling, busy/rendering
      responses and reconnect without applying a mutation twice. _Done
      2026-09-18. The bridge's whole Blender-side surface is one request type
      taking arbitrary Python (T.20.01), so a typed operation over it is built
      here, not accepted from it: the arbitrary-Python input is SPENT ONCE on an
      import, and every later call is a function on `oshun_blender_live` with a
      JSON payload whose only free choice is an operation name that must be in
      the table. THAT TABLE MOVED so both routes share it — `OPERATIONS` and the
      step loop now live in `oshun_blender_ops/dispatch.py`, imported by the
      background entry point and the live module alike (ops version 1.5.0).
      DISCOVERY IS A PROBE, not a list of assumed method names: against the
      running bridge, Blender `[5,2,1]`, `background: true`, `mainThread: true`
      (bpy is main-thread only, which is why a scene write from a request is
      legal), the six imported add-on modules, `execute` as the one accepted
      type, and the unknown-type probe rejected by name. IDENTITY, REVISION AND
      ONCE are added because the bridge has none: a call naming another session
      is refused, the open scene carries the same project/session stamp so a
      foreign file is caught, a mutation names the revision it expects, A JOB
      THAT RAN A STEP AND THEN FAILED ADVANCES THE REVISION ANYWAY and answers
      `scenePartial: true`, and a mutation id is spent whatever the outcome — a
      retry gets the recorded answer and the spec proves it on the SCENE (a box
      translated by 3 is still at x=3, not 6). BUSY IS THE CLIENT'S ANSWER
      BECAUSE THE BRIDGE CANNOT GIVE ONE: measured, a 3.0 s request delays a
      concurrent one by 2.5 s, so a second caller cannot tell busy from slow and
      an in-Blender busy flag could never fire. Two bridges on two ports stay
      two scenes, and a cross-addressed call is refused `wrong_session`.
      `startBlenderBridge` reads the add-on manifest and REFUSES TO START on a
      Blender below `blender_version_min`, proved against a manifest edited to
      99.0.0. NETWORK ISOLATION IS STATED, NOT PRETENDED: `unshare -n` would cut
      off the TCP client too, so the launcher binds loopback, builds the child
      environment, isolates `BLENDER_USER_RESOURCES` and passes
      `--disable-autoexec` — and the session is only ever given operations,
      never a caller's Python. 23 tests pass (9 without Blender, 14 against real
      5.2.1 with the v1.0.3 add-on); the whole `src/blender/` directory is 93
      passing, so the dispatch refactor moved nothing. The add-on is not
      vendored: the live tests are gated on `OSHUN_BLENDER_BIN` and
      `OSHUN_BLENDER_MCP_ADDON_DIR`. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.04._
- [x] **T.20.05** Capture geometry/material/rig state and camera renders from
      the evaluated scene, accounting for render versus viewport modifiers,
      instances, visibility, frame and simplification settings. **Verify:** a
      fixture whose viewport/render geometry differs reports both accurately;
      critic evidence comes from the intended revision/camera, not a stale
      screenshot or base-mesh polygon count. _Done 2026-09-18 against REAL
      Blender 5.2.1, as `capture.py` and `scene.py` in the T.20.02 package
      (version 1.2.0). A CRITIC QUOTING `mesh.polygons` IS QUOTING THE BASE
      MESH, which for anything with a modifier is not what renders: the fixture
      cube with subdivision at viewport 1 and render 3 is 8 VERTICES IN THE
      DATA, 26 IN THE VIEWPORT AND 386 IN THE RENDER (12, 48 and 768 triangles).
      All three are true, of three different objects, and a claim grounded in
      the wrong one is grounded in nothing — so all three are reported, per
      object, at a named frame. VIEWPORT AND RENDER ARE DIFFERENT EVALUATIONS
      AND ONLY ONE IS AVAILABLE: `Depsgraph.mode` is 'VIEWPORT' outside a
      render, measured, so the render numbers are a DOCUMENTED APPROXIMATION
      WITH A NAME — a render-equivalent viewport evaluation, mirroring
      show_render and render_levels and the render simplify level onto the
      viewport depsgraph and putting them back. The phrase ships in every result
      ("not the renderer, and nothing that happens only at render time is in
      it"), and a second capture returns an identical document, so a capture is
      not an edit. SIMPLIFY CLAMPS WITH NOTHING IN THE MODIFIER TO SHOW IT: with
      `use_simplify` on at subdivision 0 the modifier still asks for level 1 and
      the viewport evaluation is the bare cage, 8 vertices where the modifier
      says 26, so the three simplify settings are reported beside the counts.
      VISIBILITY is `hide_viewport`, `hide_render` and `visible_get()` — an
      object hidden from the render still carries all 386 vertices, which is why
      a polygon count alone says nothing about the picture. MATERIAL AND RIG
      STATE ARE READ BY VALUE: the Principled Base Color, Metallic, Roughness,
      Alpha and Emission Color (a linked socket reported as `linkedFrom`, not as
      a number it does not have), and per bone the rest head and tail, the
      parent and the posed head at the captured frame. A RENDER NAMES ITS
      CAMERA: `capture.render` takes it by name, refuses an object that is not
      one (`not_a_camera`, no file written), sets `scene.camera` from the
      payload rather than using whatever the scene was left pointing at, and
      restores camera, engine, resolution, format and path. The stamp carries
      camera, frame, engine, resolution, the caller's revision and
      `visibleTriangles` — the triangles ACTUALLY in the scene, over the
      depsgraph's instances with render-hidden objects excluded: 48 on the
      fixture, the evaluated count, not the cage's 12, and still 48 after a
      second cube hidden from the render is added. Two cameras give different
      sha256s. That is what separates a current render from one taken three
      edits ago, which a picture cannot say. **Checks:** 12 tests, and 59 across
      `src/blender`. Adding `capture.py` made T.20.02's operator-call guard fail
      until the registry declared it, which is the guard working. Targeted tsc,
      eslint, prettier and the adversarial grep clean. Not claimed: the render
      numbers are the render MODIFIER STACK, not the renderer — adaptive
      subdivision and render-time displacement are outside it and the result
      says so in words; Workbench on the CPU is the default because this box has
      no GPU, and headless rendering here also emits `EGL_BAD_MATCH` to stderr
      and produces the image anyway, with Cycles and EEVEE reachable and
      unexercised; instances are the DEPSGRAPH'S and an array modifier is not
      one (a four-count array is `instances: 1` with 32 evaluated vertices,
      because the copies are geometry); and NOTHING CONSUMES THE STAMP YET —
      T.08.04's critic evidence path is not wired to it, so the guarantee is
      enforceable with this and not yet enforced by it. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.05._
- [x] **T.20.06** Implement save/checkpoint, undoable operation groups and
      restore/reopen workflows for live changes; serialize accepted operations
      so background workers can replay them on immutable source copies.
      **Verify:** locked objects/materials stay unchanged, partial script
      failure recovers from checkpoint, and saved blend/GLB exports reproduce
      the accepted live result without overwriting newer user edits. _Done
      2026-09-18 against REAL Blender 5.2.1, as `checkpoint.py` in the T.20.02
      package (1.4.0) and `ops/checkpoint.ts`. THREE PROBLEMS WHOSE CHEAP
      ANSWERS ARE ALL WRONG. (1) UNDO IS NOT A CHECKPOINT — Blender's undo stack
      is per-session and gone when the process is, so a group that half-applied
      leaves a file nobody can describe; `applyOperationGroup` writes a `.blend`
      BEFORE the group's first step, and the test plants a failure in the middle
      of three steps then OPENS THE CHECKPOINT and compares its captured state
      object for object against the same setup saved on its own — equal, with
      neither the first nor the third transform in it — and reports which step
      failed, counted over the caller's steps rather than the prelude. (2) A
      LOCK EACH OPERATION CHECKS IS NOT A LOCK, it holds until one forgets: the
      DISPATCHER refuses a step before it runs, over the names in its payload,
      which is only possible because no operation resolves its subject any other
      way (T.20.02). `name` is DELIBERATELY NOT a subject key — it is what an
      operation CREATES, `generate` already refuses a taken name, and including
      it would make a modifier called "Locked" collide with a locked material.
      Locks come into force AFTER THE PRELUDE, because the prelude is how the
      session reached the state being locked; the first run without that refused
      the setup and returned `failedStepIndex: null`, which is how the
      distinction was found. (3) REPLAYING ONTO THE SOURCE IS NOT REPLAYING ONTO
      A COPY: the accepted document freezes the steps with the source's sha256,
      replay REFUSES a document whose source has moved on (`source_mutated`,
      naming both digests, without starting Blender), copies the source, works
      on the copy and CHECKS THE SOURCE'S DIGEST AGAIN afterwards — a replay
      that edited its own input is not reproducible and would not otherwise say
      so. Two replays give a BYTE-IDENTICAL GLB by sha256; the document carries
      its locks, so replaying a step that names a locked object comes back
      `subject_locked`. A SAVE EXPECTS WHAT IT IS OVERWRITING:
      `saveWithExpectedDigest` writes only if the target still holds what the
      caller last read, otherwise `target_changed` ("somebody saved after this
      session read it") with the file left as it is; `expectedSha256: null`
      means NOTHING SHOULD BE THERE, a different claim from "whatever is there
      is fine". **Checks:** 11 tests (4 pure), 70 across `src/blender`. Adding
      `checkpoint.py` made the operator-call guard fail again until the registry
      declared `save_as_mainfile` and `open_mainfile`. Targeted tsc, eslint (two
      `no-useless-assignment` fixed), prettier and the adversarial grep clean.
      Not claimed: THERE IS NO LIVE SESSION to check point — every "live change"
      here is a step in a background job and T.20.04 does not exist, so this is
      the mechanism it will use rather than one it is using; a checkpoint is a
      WHOLE-FILE save, not an operation-level undo, and restoring one discards
      everything after it; locks are OVER NAMES, so a step that renamed a locked
      object first would not be caught (nothing in the operation set renames,
      and adding one means adding the check); and `saveWithExpectedDigest` IS
      NOT ATOMIC — it closes the case it was written for, a save made minutes
      after a read, not a simultaneous one. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.06._
- [x] **T.20.07** Evaluate `ahujasid/blender-mcp` for measured missing features
      or older-Blender compatibility only. Inspect its telemetry and optional
      asset/generator clients and disable those outside admitted policy.
      **Verify:** pinned alternative passes the same state/scene tests and an
      outbound-traffic check; no telemetry, hidden paid calls or excluded
      Hunyuan generation is introduced into the open profile. _Done 2026-09-18,
      AND THE ANSWER IS NOT ADOPTED. Cloned at the pinned commit `5f8ddaf6`,
      read, run on Blender 5.2.1 and traced. MEASURED MISSING FEATURES: NONE
      WORTH A SECOND TRANSPORT — `get_addon_info` reports nine capabilities, of
      which `execute_code` takes arbitrary Python, the same shape as the Lab
      bridge, and it adds no operation the T.20.02 package already lacks. THE
      ONE THING THAT KEEPS ITS ROW is the older-Blender clause: its add-on
      declares `bl_info["blender"] = (3,0,0)` where the Lab add-on declares
      5.1.0, and the GPU worker image installs 4.0.2, so it is the only bridge
      that could load there. IT CANNOT SERVE A HEADLESS WORKER IN ITS OWN WORDS
      — under `blender -b` it prints "commands would never execute" and stays
      stopped, because its queue drains from a `bpy.app.timers` callback; every
      live measurement therefore ran under `xvfb-run`. ENABLING THE ADD-ON OPENS
      THE SOCKET: `register()` auto-starts the listener on 9876, so a bridge
      whose one general capability is arbitrary Python begins listening with
      nothing pressed. THE OPTIONAL CLIENTS ARE GATED STRUCTURALLY: Poly Haven,
      Hyper3D Rodin, Sketchfab, Poly Pizza and Tencent Hunyuan3D each sit behind
      a scene boolean defaulting to false, and while it is false the handler is
      NOT IN THE TABLE — `Unknown command type`, measured for all fifteen.
      TELEMETRY DECIDES THE INSTALL ROUTE: consent defaults to TRUE (read live,
      not from the README) and covers "prompts, code snippets, screenshots, and
      trajectory data", but the endpoint lives in `src/blender_mcp/config.py`,
      WHICH IS GITIGNORED AND UNTRACKED — the pinned checkout cannot initialise
      the collector at all, while the published `mcp-for-blender` 2.0.0 wheel
      ships it with a host, a key and `enabled: True`. So the pinned install is
      not telemetry-disabled, it is TELEMETRY-ABSENT. OUTBOUND-TRAFFIC CHECK:
      under `strace -f -e trace=connect`, consent left at its default true, all
      seven always-on commands driven — eleven `connect()` calls, nine AF_UNIX
      (nscd, pulse, X) and two AF_INET to 127.0.0.1 port 0, ZERO NON-LOOPBACK.
      Checked in: the evaluation as data, the policy gate that names each
      refusal separately, the decision with its four conditions, and the
      community protocol client (a JSON object with NO TERMINATOR, unlike the
      Lab bridge's null byte). 17 tests pass, 11 without Blender and 6 against
      the real add-on. Two harness defects found and fixed: killing the
      `xvfb-run` handle orphans Blender and the X server, and `server.stop()`
      restarts the old server on its old port because only the stop OPERATOR
      deletes the object. Evidence: `docs/agents/isis-3d-studio-evidence.md`
      T.20.07._
- [x] **T.20.08** Complete real Blender -> GLB/FBX -> viewer/engine round trips
      covering mesh, PBR, skeleton, animation, cameras and source preservation.
      Benchmark interactive iteration versus fresh background execution.
      **Verify:** parsed artifacts and rendered comparisons agree within target
      tolerances; bridge availability alone does not satisfy T.16 export gates,
      and older-worker/newer-session incompatibilities are reported explicitly.
      _Done 2026-09-18. T.16.01's feature-loss matrix is a CLAIM; this is the
      measurement that checks it, and its value is being able to say the matrix
      was wrong — WHICH IT WAS: the FBX profile says a take is named
      `<armature>|<action>` and `io_scene_fbx` writes `Rig|Rig|Wave`, the
      armature name twice. Two operations were missing and are now in the
      package (ops 1.6.0): `export.fbx` with the units and axes the profile
      declares, and `import` for glTF/GLB, FBX, OBJ, PLY, STL, USD and Alembic,
      each importer written out as its own call because `job.spec.ts` GREPS the
      package for operator calls and a `getattr` lookup passed the declaration
      and failed the grep. THE READER IS NEVER THE WRITER: every trip exports
      from one Blender and imports into a fresh one, and glTF gets a second,
      independent reader (`@gltf-transform/core`) because Blender's importer
      cannot report a metallic factor. THREE THINGS A NAIVE COMPARISON GETS
      WRONG, ALL MEASURED: a box is 8 vertices / 6 polygons and comes back 24 /
      12 through glTF and 8 / 6 through FBX, with 12 TRIANGLES BOTH WAYS — so
      geometry is compared on triangles and bounds and the index change is
      reported, not failed; Blender's glTF importer ADDS AN ICOSPHERE that was
      never in the source (and a `neutral_bone` when weights are partial), which
      is reported as added rather than counted as a survivor; and a clip is
      matched on its FRAME RANGE because both formats rename and both bake (3
      curves became 20 and 29). ABSENT IS NOT KEPT: the four features the
      authored scene never exercised come back `unobserved`, confirmed by the
      parser, and the gate refuses `feature_unobserved` when asked to certify
      one. BRIDGE AVAILABILITY IS NOT EVIDENCE: the gate reads the comparison,
      refuses `no_artifact_parsed` before anything else, and `bridgeAvailable`
      only changes the wording. Version skew names WHICH SIDE IS OLDER, because
      that is the direction that breaks. BENCHMARK, five cycles each on this
      box: interactive median 6 ms (first cycle 75 ms, which is staging) against
      background median 784 ms — **130x**, the whole difference being a Blender
      process start. Two of my own bugs were caught by the tests and fixed:
      `unobserved` was ranked as the worst outcome so one unparented object
      silenced a broken bone hierarchy, and `claimWithinCeiling` answers the
      opposite question and passed every `partial` against a `kept` ceiling. 24
      tests pass, 17 without Blender and 7 against 5.2.1. THE WHOLE LIBRARY IS
      GREEN FOR THE FIRST TIME — 375 tests, 52 files: twelve spec files had been
      failing on four packages missing from this worktree's link farm (`three`,
      `zod`, `meshoptimizer`, `xatlasjs`), all already in the pnpm store, and
      those failures had been called pre-existing. NOT DONE HERE: loading the
      result in Three.js, Godot, Unity or Unreal — that is T.16.03 to T.16.05,
      and the independent reader here is a parser, not an engine. Evidence:
      `docs/agents/isis-3d-studio-evidence.md` T.20.08._

## T.21 Agent-tool effectiveness, isolation and release qualification

Dependencies: available T.19/T.20 routes; extends T.17/T.18, not a new release.

- [ ] **T.21.01** Define matched agent tasks: Unity inspect/import/prefab edit,
      runtime bug diagnosis, animation/collision validation and build/test;
      Blender procedural assembly, material/rig edit, targeted repair and
      render/export. Compare official direct/bridge, qualified community and UI
      fallback routes with the same inputs/model/budget. **Verify:** a versioned
      rubric, independent success assertions and retained failed runs.
- [ ] **T.21.02** Measure task success, persisted correctness, quality,
      tool/schema tokens, call count, elapsed/cold-start time, retries and
      actual total cost. Choose the route per operation and supported version,
      not star count or a blanket MCP preference. **Verify:** repeatable
      comparison with sample sizes and uncertainty; no claim that transport
      alone improves model reasoning, and routine harnesses keep the existing
      cheap-model binding.
- [ ] **T.21.03** Add failure/isolation tests for arbitrary script execution,
      prompt injection in scene metadata, wrong-session targeting, stale writes,
      denied I/O, leaked credentials, malicious assets and remote disconnects.
      Keep local tool ports private and put any remote access behind the Isis
      authenticated worker boundary. **Verify:** process/resource/network limits
      and one-writer revision checks hold for CLI, MCP and advanced eval alike.
- [ ] **T.21.04** Exercise controller -> live edit -> numerical/visual QA ->
      persisted revision -> headless export -> real engine playback as an
      end-to-end flow. Test manual steering and multiple critic snapshots.
      **Verify:** retained evidence proves scene/asset correctness after reopen,
      no stale job overwrites newer work, and applicable dashboard Playwright
      journeys expose actual state rather than tool-call acknowledgements.
- [ ] **T.21.05** Ship pinned agent skills, setup/diagnostic runbooks, transport
      selection rules, session lifecycle and upgrade/rollback procedures.
      **Verify:** a clean admitted runner discovers, connects, edits, verifies,
      saves and shuts down without manual log copying; an unavailable bridge
      selects only a qualified fallback and releases resources on exit.
- [ ] **T.21.06** Extend T.17.06's acceptance matrix with Unity CLI/Pipeline,
      Unity MCP, Blender headless and Blender Lab MCP profiles plus any selected
      community fallbacks. Publish measured recommendation and limitations.
      **Verify:** required cells pass before their T.18 rollout; direct and MCP
      routes share policy/lineage/cost guarantees, and optional Unity remains
      independent of the fully self-hosted Blender/Three.js/Godot profile.
- [ ] **T.21.07** _(added 2026-09-18 from ADR-0008 Q5 and the board audit)_
      Audit `libs/bellona/blender-agent`, `libs/bellona/unity-agent` and
      `libs/bellona/cross-dcc-consistency` against T.20 and T.19 with both
      passes of the checkbox rule, one row per public operation: real
      computation, catalogue with no data, or fabricated result; and for each
      real one, whether T.20.02 already implements it. Record the table in
      ADR-0008 under Q5 in its merged / superseded / independent vocabulary.
      Where both sides implement an operation, the T.20.02 module is kept and
      the Bellona one becomes a caller of it (decisions block of 2026-09-18).
      **Verify:** the table covers every export of the three packages; a spec in
      `libs/bellona/blender-agent` fails if it defines a Blender operation that
      `libs/isis` also exports; `apps/bellona/remote-host` still builds; and Eve
      task 5.5 and workbenches cell B8.1 each cite the table.

## T.22 Meshy hosted 3D lane (added 2026-09-15)

Owner decision 2026-09-15: "i do want meshy not against license terms but also
our pipelines support as option for allowed use cases". Meshy becomes an
optional hosted generation lane beside the self-hosted T.05 path, used where its
terms allow; it does not replace the self-hosted work and no pipeline may
require it (plan item 3 stands). Terms read 2026-09-15 at
https://www.meshy.ai/terms-of-use ("Last Updated: September 19, 2026" as
served), https://www.meshy.ai/acceptable-use-policy and the pricing FAQ:

- Outputs: on a paid plan the customer owns what it generates (pricing FAQ; Pro
  includes API access and private assets); free-plan outputs are CC BY 4.0 with
  attribution (terms 3.2). Commercial use of outputs is allowed.
- Restrictions (terms 2.6): no competitive products or services and no
  competitive analysis (iv), no reselling or redistributing the Service or
  access to it (v), no shared accounts (vi), no training AI models that compete
  with Meshy on generated assets (xi), and the acceptable use policy, which
  forbids pornographic material.
- Meshy may train on inputs and outputs of non-Enterprise customers (2.9) and
  embeds AI identifiers that must not be removed (2.4).
- The API key in the owner's environment authenticates; balance 825 credits on
  2026-09-15.

**Full capability scope (owner, 2026-09-15: "ensure we are building capability
to use all capabilities of meshy").** The documented API on 2026-09-15
(https://docs.meshy.ai/en/api/quick-start navigation and
https://docs.meshy.ai/llms.txt), every item in scope:

| Group           | Capabilities                                                                                          | Maps onto        |
| --------------- | ----------------------------------------------------------------------------------------------------- | ---------------- |
| Generation      | Text to 3D v2 (preview, refine), Image to 3D, Multi Image to 3D, Text to Image, Image to Image        | T.05, T.07, T.10 |
| Mesh operations | Remesh, Convert, Resize, UV Unwrap, Retexture                                                         | T.09, T.10, T.16 |
| Characters      | Rigging, Animation (preset library, merged actions), Text to Motion                                   | T.11, T.12, T.13 |
| Operations      | Balance, Usage, Webhooks, task get/list/delete and SSE streams, rate limits, asset retention, pricing | T.03, T.18       |
| Agent channels  | Meshy MCP server, llms.txt, CLI, Blender and Unity plugins                                            | T.19, T.20, T.21 |

Text to Motion is the first text-to-motion source in this tracker whose outputs
the customer owns; T.12.07's licensed-data gap still stands for self-hosted
models. Excluded by the owner on 2026-09-15 ("remove the 3d printing and
creative lab stuff"): the 3D printing endpoints (Multi-Color Print, Analyze and
Repair Printability, Auto Split) and every Creative Lab product. The coverage
check lists them as excluded, not missing.

- [x] **T.22.01** Encode the allowed-use policy for the Meshy lane:
      `content_policy: sfw_only` (the AUP), inputs limited to material the
      operator may send to a vendor that can train on it (no tenant uploads
      without that consent), AI identifiers preserved, never a benchmark or
      comparison input (T.01.15, T.17.02), never a training input for Isis
      models, and operator/internal production use only until an owner decision
      or a written Meshy confirmation or Enterprise Order settles whether
      tenant-facing generation is reselling access (2.6 v) or a competitive
      service (2.6 iv). **Verify:** specs refuse each forbidden use at submit,
      in the catalog and on retry, and the decision on tenant exposure is
      recorded with its date and source. _2026-09-15, built, stays open for the
      dated tenant-exposure decision (the checked-in default is operator only):
      `hosted-lane-policy.ts` refuses non-operators (403), anything but a
      neutral rating or with Meshy moderation off (422), any use other than
      production (benchmark, comparison, evaluation, training: 403), uploads
      without a declared origin, tenant uploads without a vendor-training
      consent id, and other tenants' material, at submit, every chain step,
      retry, execution and the catalog; stored outputs must hash as downloaded
      so Meshy's AI identifiers survive. The vendor-training consent id has no
      consent store to check against yet._ _**Done 2026-09-15.** Tenant exposure
      asked and answered in this session: "Operator only, final". The checked-in
      decision carries `final: true`, that source and a new owner decision as
      its only reopen condition. The unverifiable consent id no longer admits
      anything: a tenant upload is refused with
      `hosted_lane_vendor_training_consent_unverifiable` (403) until a
      vendor-training consent registry exists. Specs: three-d capabilities 222,
      Meshy lane route 19 (refusals at submit, chain step, retry and catalog).
      Evidence: `docs/agents/isis-3d-studio-evidence.md` T.22.01._
- [x] **T.22.02** A Meshy client on the current OpenAPI (text to 3D preview and
      refine, image and multi-image to 3D, retexture, remesh, rigging and
      animation where the account has them; extended 2026-09-15 to every
      capability in the scope table above, typed per endpoint, with SSE streams,
      webhook signature checks and credit prices for pre-submit estimates),
      configured through `@oshun/config` (`MESHY_API_KEY`), with task ids
      persisted for idempotent polling, rate limit and credit errors surfaced as
      typed failures, and the balance read before submit. Replace or retire the
      stale `meshy-provider.ts` in `@isis/3d-generation` (it targets
      `api.meshy.ai/v2`). **Verify:** client specs against recorded response
      shapes; no production file reads `process.env`. _**Done 2026-09-15.** One
      typed client in `@isis/ai-providers` (`providers/meshy`) for 13
      capabilities with create, get, list, delete and SSE stream, balance,
      usage, the animation library, typed errors and documented credit prices;
      `ensureTask` never re-creates a recorded task. Meshy documents no webhook
      signature, so webhooks count as unverified and the lane polls.
      `MESHY_API_KEY` is read through `@oshun/config`. The stale `/v2` provider
      in `@isis/3d-generation` is deleted. Specs 69 against doc fixtures; one
      live balance read returned 825._
- [x] **T.22.03** Wire the lane into the generation API: a 3D job routed to
      Meshy under T.22.01's policy and the 3D capability state, credits
      converted to USD in the cost ledger with a daily budget, outputs (GLB and
      textures) copied into the Hetzner outputs store, a provenance record
      naming the provider, task id and plan, and the output classified through
      `evaluateThreeDDerivation` (T.01.05). **Verify:** route and executor specs
      with the HTTP boundary mocked, including refusal paths and a retried job
      that does not submit a second Meshy task. _2026-09-15, built, stays open
      for its live counterpart T.22.04: jobs naming `meshy:<capability>` go to
      the lane before the ComfyUI resolver; the Meshy task id is recorded before
      the first poll so retries and recovery resume it; a credit ledger books
      consumed credits at 0.02 USD each (Pro list price) against a 2 USD daily
      default and fails closed; outputs (GLB and other model types added to the
      output store) persist byte-identical with provenance naming meshy, the
      task, consents and the lineage class. The lane has its own readiness
      record at offline-verified; self-hosted 3D states are unchanged. Specs 73
      with the HTTP boundary mocked._ _**Done 2026-09-15.** The live counterpart
      ran (T.22.04, T.22.10): six Meshy tasks through the API as the operator,
      credits booked from `consumed_credits`, outputs stored byte-identical
      under `isis/outputs/jobs/<jobId>/` on Hetzner (the API output store first
      gained its missing S3 SDK dependency and `ISIS_OUTPUT_S3_KEY_PREFIX`), and
      a retried job resumed task `01a0a6f8` without a second create. Two defects
      the live run found are fixed with specs: one dropped poll connection
      failed the job (`waitForTask` now retries 5 transient poll failures), and
      a GLB named twice was stored twice (outputs keep one file per URL). The
      lane record gained a `live-rendered` rung whose evidence is those tasks,
      and a mode is live-ready only if its capability rendered. Specs: Meshy
      client 72, lane and capabilities route 51, three-d capabilities 224._
- [x] **T.22.04** One live text-to-3D and one live image-to-3D job through the
      API as the operator, with credits spent, wall time and the output checked
      (mesh opens, triangle count, textures present), on the owner's go for the
      credits. **Verify:** evidence records task ids, credits and hashes.
      _**Done 2026-09-15, on the owner's go (up to 80 credits) and after the
      Task 14.2 owner attestation.** Text to 3D: preview task `01a0a6f0` (20
      credits, 170 s, GLB 13 551 644 B `f284fb32…`, 752 936 triangles) and
      refine `01a0a6f3` (10 credits, 290 s, GLB 28 364 336 B `f427e29f…`, 4
      embedded textures plus PBR maps). Image to 3D from an operator-owned
      Chroma still: `01a0a6f8` (30 credits, 292 s, GLB 20 687 232 B `fefd20c4…`,
      378 286 triangles, 4 textures), after one job failed on a dropped poll and
      its retry resumed the same task. Thumbnails match the prompt and the
      source. Evidence: `docs/agents/isis-3d-studio-evidence.md` T.22.04 and
      T.22.10._
- [x] **T.22.05** Retire the duplicate Meshy callers: the Oshun sky-briefing
      fallback (which reads `OSHUN_MESHY_API_KEY` while the environment holds
      `MESHY_API_KEY`) and `apps/lilith/svc-ai`'s Meshy module move onto the one
      client or are removed. **Verify:** one Meshy client in the repository and
      its callers' specs pass. _2026-09-15, partly done: the Oshun sky-briefing
      Meshy fallback is removed and the key name fixed; `apps/lilith/svc-ai`'s
      Meshy module makes no HTTP calls and stays. Stays open:
      `libs/bellona/text-to-3d/src/transport.ts` and the
      `3d-generation-benchmarks` Meshy runner still call Meshy directly (the
      benchmark runner must go under T.01.15)._ _**Done 2026-09-15.** The last
      two direct callers are gone. `@bellona/text-to-3d` no longer ships
      `createMeshyTransport` or `mapMeshyStatus`: another product calling Meshy
      would bypass T.22.01 and the owner attestation, which covers only the Isis
      generation API. Its tests (20) pass on the Tripo transport. The benchmark
      runner is deleted under T.01.15. A repository scan for `api.meshy.ai` and
      the Meshy task paths finds only the one client, the lane, the config
      default and comments. `MESHY_API_BASE_URL` is also refused off
      `api.meshy.ai` (config spec 20)._
- [x] **T.22.07** _(added 2026-09-15)_ Capability coverage check: a checked-in
      snapshot of Meshy's documented endpoints (llms.txt and the docs
      navigation, with the fetch date) and a spec that fails when a documented
      capability has no client method, policy entry or API route (the
      owner-excluded printing and Creative Lab groups are recorded as excluded),
      plus a `--check-remote` drift report that re-reads llms.txt and names
      added or removed endpoints. **Verify:** the spec passes on the snapshot
      and fails on a fixture that adds an endpoint. _**Done 2026-09-15.**
      `meshy-api-surface.snapshot.json` lists 173 documented endpoints (68
      covered, 105 print and Creative Lab endpoints excluded by owner decision),
      a spec fails on any uncovered endpoint or a capability without a policy
      mode or runner, and `meshy-api-surface.ts --check-remote` re-read the live
      docs with no drift._
- [x] **T.22.08** _(added 2026-09-15)_ Chained Meshy operations as persisted job
      chains that resume by task id: text or image to 3D, then remesh, UV
      unwrap, retexture, rig and animate. **Verify:** chain specs with the HTTP
      boundary mocked show each step resumes without a second task and a refused
      step stops the chain. _**Done 2026-09-15.** `meshy-lane-chain.spec.ts`
      runs text to 3D → remesh → UV unwrap → retexture → rig → animate through
      the real runner, chain service and advancer with only Meshy's HTTP mocked:
      one create per step, each naming the previous task; a step re-run after
      its task was recorded resumes it without a second create or booking; a
      rigging 400 stops the chain. The advancer weighed Meshy steps against a
      RunPod ledger; they now use the Meshy ledger (both cases fail without the
      fix). 89 specs across the lane and chain suites. Evidence: T.22.08 in the
      3D studio file._
- [x] **T.22.09** _(added 2026-09-15)_ Agent channels: evaluate the Meshy MCP
      server, CLI and the Blender and Unity plugins against T.19 to T.21's
      isolation and qualification rules (credentials never in an agent's
      context, spend caps, the T.22.01 policy), and adopt or reject each with a
      recorded reason. **Verify:** a decision record per channel. _**Done
      2026-09-15.** `docs/domains/isis/adr/ADR-0009-meshy-agent-channels.md`,
      from Meshy's docs and integration pages read the same day, has one
      decision per channel. The MCP server (`@meshy-ai/meshy-mcp-server`) is
      rejected: the key sits in the agent's environment, calls spend credits
      outside the Isis ledger and skip T.22.01's policy, provenance and the
      output store, it exposes the excluded print tools, and it installs by
      floating `npx -y`. The `add-mcp` CLI and `meshy-3d-agent` skill pack are
      rejected for the same reasons. No standalone Meshy CLI is documented. The
      Blender and Unity plugins are rejected as Isis channels, because their DCC
      Bridge imports from the Meshy web workspace outside every Isis gate. Isis
      instead imports lane outputs through T.20 and T.19. Each rejection names
      what would reopen it._
- [x] **T.22.10** _(added 2026-09-15)_ One live proof per capability group
      (generation, mesh operation, character), on the owner's go for the
      credits, each with task ids, credits and output checks. **Verify:**
      evidence per group; nothing marked rendered without a task id. _**Done
      2026-09-15.** Generation: the three tasks in T.22.04. Mesh operation:
      remesh `01a0a6fe` of the refined robot (5 credits, 31 097 triangles).
      Character: rigging `01a0a701` (5 credits, 1 skin, 24 joints, after Meshy
      refused the unremeshed 752 936-face mesh with 400 at no charge) and
      animation `01a0a705`, library action 2 "Alert" (3 credits, one 72-channel
      clip). 73 credits in all; balance 825 → 752. Every task id, credit count
      and output sha256 is in the evidence table._
- [ ] **T.22.06** Offer the lane in the Isis 3D workspace (T.15) with its policy
      visible: SFW only, the operator scope, credits per job. **Verify:** a
      Playwright check of the selector and the refusal messages.

## E.00 Toolbox extension: phase control, space and pull order (added 2026-09-14)

- [ ] **E.00.01** Evidence and proof policy:
      `docs/agents/isis-chroma-runpod-evidence.md` gains `## E.00`–`## E.08`;
      every live render records `delayTime`, `executionTime` and settled USD
      through `runpod-catalog-run.mjs` or `motion-live-proof.mjs` (the balance
      read at least 10 minutes after the last job, twice) and flips its catalog
      entry to `proof_level: rendered` with a measured rate; one live render per
      new model, LoRA and mode. Estimate and ask before spending: video clips
      about $8–15 (Wan-Dancer, two S2V and two HuMo bake-off clips, the
      performance workflow, Uni3C, The Walk, two stylised-identity clips),
      stills about $1–2; the benchmark run (E.01.05) quotes its own capped
      budget.
- [ ] **E.00.02** Space plan before any pull: re-read the Hetzner library
      listing (the 813.38 GB at A.00.03 predates later retry pulls) and the
      account's 1 TB allowance, which `isis/outputs/` shares. The extension adds
      about 164.06 GB with both bake-off models present (footprint table).
      A.05.03's retirements (117.71 GB) land first, the E.03.04 loser leaves the
      library and the cache once the user has picked, and Qwen-Image-Layered
      (41.12 GB) is pulled only on the user's go. Record before and after
      totals; the library stays under the 900 GB alarm line at every step, and a
      pull that would cross it stops before any byte moves.
- [ ] **E.00.03** Rows before bytes (A.00.04's pattern): every E model gets its
      manifest row first — Hugging Face rows with the 40-hex revision and LFS
      oid from the 2026-09-14 facts, Civitai rows with model, version and file
      ids, the version API's SHA-256 and the exact byte count from a one-byte
      ranged download — plus family ids (L.02.01), `sharedBy` for shared files
      (umt5, CLIP vision H, the Wan 2.1 VAE, the Flux `ae`, the Qwen2.5-VL
      encoder), a register row in the same commit (E.07.03) and a `--strict`
      lint run green. Pulls go through `library-pull` pods (L.01.04). A Civitai
      version with a non-null `paidAccess` or an open early-access window is
      refused when its row is written, not at download. Non-ASCII filenames
      (`参考色调.safetensors`) get an ASCII library key and `destPath`. Re-read
      sizes and hashes against the APIs before pulling; the facts block is a
      snapshot.

## E.01 Benchmark, per-lane routing and body-LoRA evaluation

- [x] **E.01.01** Benchmark suite as a checked-in file under
      `libs/isis/workflows/src/benchmarks/`: fixed prompts, seeds, shapes and
      reference inputs per lane — photoreal portrait, nude yoga and figure study
      (`adult_ok` workflows only), dance and movement, sets and environments,
      costume and wardrobe, anime and stylised, typography — with the Isis
      workflows each lane runs on and, for SFW prompts only, the E.01.04 API
      reference. Reference images and driving clips are Oshun-owned or cleared
      and carry consent ids (C.12.14's registry). A spec validates every entry
      against the catalog, so a renamed workflow fails the suite, not the run.
      _2026-09-16. `libs/isis/workflows/src/benchmarks/benchmark-suite.ts`: 14
      entries across all eight lanes, 12 runnable today, every prompt, seed and
      shape a checked-in literal. **The spec is the part that earned its place**
      — it validates each entry's workflow id, every pinned input name and every
      enum value against the real catalog definitions on disk, and it caught
      **12 wrong values in the first draft** (invented aspect names like
      `portrait` where the catalog says `portrait_896x1152`, and a Qwen entry
      pinned to a HiDream aspect). Every one of those would have been a billed
      failure or a silently different shape. **Policy is data, not runner
      discipline:** the three adult-lane entries are `apiReference: false` and
      run only on `adult_ok` workflows, both spec-enforced, so an adult prompt
      cannot reach E.01.04's external reference by an edit to the runner. Nine
      entries are cleared for the API reference, all neutral. **References are
      Isis's own material or the entry is honestly blocked:** `wan22-i2v` and
      `qwen-edit` take a start frame from an earlier entry in the same suite
      (operator self-consent, which C.12.14 settled as the correct record for a
      typed prompt), and the two entries that need something Isis does not have
      stay visible as `blocked` with the item that unblocks them —
      `scail2-animate` needs a cleared driving clip (E.03.08) and the anime
      entry needs a dedicated anime base (E.06.03). Dropping them would have
      made those lanes read as covered; pointing them at stock footage would
      have put uncleared likeness through the lane. A spec also refuses a lane
      whose only entries are blocked. 93 specs. Evidence: `## E.01`._
- [ ] **E.01.02** Scoring: a blind rubric per lane — anatomy, soft-tissue
      motion, prompt adherence, identity hold, style fidelity, set and wardrobe
      consistency, and act-bleed (sexual poses, framing or a second person the
      prompt did not ask for) — scored by a person on anonymised outputs in a
      dashboard view, plus cost per accepted output from measured rates. The
      score store records rater, output hash and rubric version. No automated
      judge stands in for a missing human score; an unscored output stays
      unscored. _2026-09-16, the rubric and the aggregate are built and
      specified; stays open for the score store and the dashboard view.
      `libs/isis/workflows/src/benchmarks/benchmark-rubric.ts` holds six
      criteria, each with what a **1** and a **5** look like — a 1–5 with no
      anchors is a mood, not a rubric — and `BENCHMARK_LANE_CRITERIA` gives each
      lane only the criteria it can answer, so typography is never scored on
      soft-tissue motion and a number that means nothing never reaches an
      average. **Act-bleed is typed separately** (sexual pose, sexualised
      framing, unrequested second person) because it is a defect count where
      higher is worse — the opposite direction from every other column — and
      E.01.06 needs it per body-LoRA rather than folded in.
      `validateBenchmark-     Score` **rejects rather than coerces**: no rater,
      a criterion the lane does not use, a value off the scale, an older
      `rubricVersion`, a missing output hash. `blindLabelFor` gives the rater
      `sample-<8 hex>` from the output bytes — stable, and carrying no workflow,
      model or checkpoint. `summariseBenchmarkLane` reports `scored` and
      `unscored` beside every mean, returns `null` rather than 0 when nobody has
      looked (0 would read as "scored, and terrible"), and prices an accepted
      output against everything the lane spent, rejects included, because the
      rejects are part of what the keeper cost. 24 specs, 117 in
      `src/benchmarks/`. **What is left:** the score store that persists these
      records in the generation API, and the dashboard view a person scores in —
      the item's own "in a dashboard view"._
- [ ] **E.01.03** Benchmark runner: submits a suite run through the generation
      API as the operator tenant with consent ids attached, writes outputs under
      `isis/benchmarks/<runId>/` in the Hetzner bucket, keeps them out of the
      Outputs gallery and every tenant-facing listing, and writes one results
      file per run (workflow, seed, measured cost, output hash, score state).
      Video jobs are warm-chained as `motion-live-proof.mjs` does. Tested down
      to one real still.
- [ ] **E.01.04** SFW API reference through the existing
      `@isis/seedance-provider`: the suite's SFW prompts (sets, wardrobe,
      clothed dance, typography, anime) run once against the provider's current
      Seedance model id, read at run time, with the per-call price taken from
      the provider's response or invoice, never estimated. `adult_ok` prompts
      never go to an external API. Ask before spending.
- [ ] **E.01.05** Benchmark run and routing decision: a suite run per lane once
      that lane's E.02–E.06 items have rendered, each run's budget quoted and
      approved first; results and scores in evidence `## E.01`. The user then
      decides per lane — self-host, API, or both — recorded in a "Decisions
      taken by the user" block with the numbers behind it. `adult_ok` lanes stay
      self-hosted by construction.
- [ ] **E.01.06** Body-LoRA A/B: the suite's nude-yoga, figure-study and dance
      prompts run with and without each body and motion option already in the
      library — the Wan pairs NSFW Posing Nude, Bouncing Boobs, Twerking, Slow
      Twerk, Hip sway and Hip Bump Dance; the Wan and Z-Image breast sliders;
      PhotoReal BetterNudes, NSFW Realism and NiceGirls UltraReal; the
      UnGloryHail checkpoint — at the same seeds, scored with E.01.02's rubric
      with act-bleed reported per option. The user then decides keep or prune
      for each; a pruned option leaves the manifest, the library, the cache,
      every enum and the register in one commit. No sex-act LoRA is pulled for
      this.
- [ ] **E.01.07** Own body-physics LoRA, scoped only: a Wan 2.2 I2V high/low
      pair (and a Z-Image LoRA if E.01.06 shows a still-image gap) trained
      through `libs/isis/lora-training-surface` on nude yoga and dance footage
      that Oshun owns or has cleared, with every performer's consent in the
      registry. Precondition, not agent-actionable: that footage and those
      consents exist. Until then this stays `[ ]` with that note; once met, the
      item is re-scoped with dataset size, training cost and E.01.06's protocol
      as its acceptance test. _2026-09-18, board tag: the precondition is owned
      or cleared footage with every performer's consent in the registry, which
      this item says is not agent-actionable._ `blocked:corpus`

## E.02 Prompt assist (visible, editable, fail loud)

- [ ] **E.02.01** Backend measurement before building: a fixed set (nude yoga,
      figure study, music-video wardrobe, a set description, an anime character,
      three reference images, two driving clips) run through each candidate —
      OpenRouter `deepseek/deepseek-v4-flash-0731` with price sort (the repo's
      binding) for text, and core `TextGenerate` on `qwen_2.5_vl_7b`,
      `gemma4_e4b_it_bf16` and `qwen_3_4b` in the graph — recording refusal
      rate, sanitising (the rewrite drops or covers nudity the input asked for),
      invented detail (clothing, props or people not in the input) and cost per
      call. The user picks the text backend and the caption backend from the
      table. A frontier model is not a candidate without asking (repo cost
      rule).
- [ ] **E.02.02** Text rewrite in the generation API: a prompt and a workflow id
      in, a rewrite out, built from that family's official template — Z-Image's
      `pe.py`, Wan's prompt-extend system prompts, Qwen-Image's polish template,
      natural-prose photography language for Chroma, the tag-and-prose form the
      NetaYume card documents — with the template version in the response. A
      refusal, an empty reply, a reply that fails the template's expected shape
      or a timeout is an error with its reason; the original prompt is never
      silently swapped. Content policy applies to the rewrite as to any prompt.
      OpenAPI regenerated; one focused spec covering each failure mode.
- [ ] **E.02.03** Reference captions in the graph: a `TextGenerate` stage on the
      E.02.01 caption backend writes an identity caption from the reference
      image (face, hair, clothing, materials, markings) and an action-and-scene
      caption from the driving clip, returned to the Studio for editing before
      the video job, for `wan22-i2v`, `wan22-animate-2` and `scail2-animate`.
      The encoder joins the families of the workflows that use it (Gemma 4 E4B
      is library-only today and the Qwen2.5-VL encoder sits in the Qwen-Image
      family), and the cache closure is recomputed. One live caption per input
      kind.
- [ ] **E.02.04** Studio: "Enhance prompt" and "Describe reference" actions on
      the Jobs page, a side-by-side view of the original and the rewrite,
      editing before submit, and E.02.02's error states shown as errors.
      Chromium check only.
- [ ] **E.02.05** Optional prompt enhancement on `ltx25-av` through the core
      `LTXVGemmaEnhancePrompt` node on the Gemma 4 encoder the graph already
      loads; SFW only, off by default, the enhanced prompt returned with the
      job. Validated, then one live clip.

## E.03 Dance, music video and camera

- [ ] **E.03.01** lightx2v I2V 480p rank-64 distill LoRA row and pull (738 005
      744 B, `Kijai/WanVideo_comfy` @ `8260d429…`). Its register row records the
      provenance: an extraction from Apache-2.0
      `lightx2v/Wan2.1-I2V-14B-480P-StepDistill-CfgDistill-Lightx2v`, in a
      repository with no licence tag. It unblocks the Wan-Dancer template
      (E.03.03), the Animate-2 base schedule (A.01.06) and SCAIL-2's turbo path
      (A.02.06); those items keep their own proofs.
- [ ] **E.03.02** Wan-Dancer-14B rows and pull: `global_model.safetensors` and
      `local_model.safetensors` from `Wan-AI/Wan-Dancer-14B` @ `85ce88dd…`
      (68.98 GB, all BF16 by header). The Comfy-Org fp8 repack is not taken.
      First proof: one real load of both files on a video worker through the
      core loader (the build validator's zero-byte shadow files cannot show it);
      if the loader refuses the native key layout, stop and record the error for
      a user decision rather than converting the weights.
- [ ] **E.03.03** `wan-dancer` motion workflow from the ComfyUI Wan Dancer
      template: reference image, music track, a genre enum (Chinese classical,
      K-pop, street, tap, Latin), the motion-amplitude and duration inputs the
      template exposes, the global keyframe pass then local refinement, and the
      music muxed into the output. `content_policy: adult_ok` (Apache-2.0, no
      acceptable-use clause) with its policy note. Validated, then one live clip
      at the smallest shape the template allows; rate written.
- [ ] **E.03.04** S2V and HuMo bake-off: rows and pulls for
      `wan2.2_s2v_14B_bf16` with `wav2vec2_large_english_fp16` (33.22 GB) and
      `humo_17B_fp16` with `whisper_large_v3_fp16` (37.20 GB); the text encoder
      and VAE each template loads are read before the rows and become shared
      rows where the oids match. Two clips each from the same singing audio and
      reference still (one half-body, one full-body), scored on lip-sync, body
      motion, identity hold and wardrobe control from the prompt; the user picks
      the winner. The loser's rows, library objects and cache files are deleted
      in one commit and it stays listed in the register.
- [ ] **E.03.05** Performance workflow for the E.03.04 winner (`wan22-s2v` or
      `humo-performance`): still or reference image, audio track, prompt and
      length, plus, for S2V, the extend stage (`WanSoundImageToVideoExtend`) for
      songs longer than one window. `content_policy: adult_ok`. Validated, then
      one live clip of at least two windows (S2V) or the model's maximum length
      (HuMo).
- [ ] **E.03.06** Uni3C camera control: a row for `ewrfcas/Uni3C`
      `controlnet.pth` (3.99 GB, Apache-2.0, a pickle loaded only by the core
      node) and a `camera_reference` input on `wan22-i2v` that applies a
      reference clip's camera path through `WanUni3CControlnetApply`. The model
      was trained on Wan 2.1 I2V, so one live clip on the Wan 2.2 experts
      decides: a clip whose camera follows the reference keeps it; otherwise the
      row and input are removed and Wan 2.2 Fun Camera (59.16 GB, V.12.04) is
      recorded as the fallback decision for the user.
- [ ] **E.03.07** The Walk pair (tier 2): Civitai 1363473, High-Normal 2254373
      and Low-Normal 2254403, on `wan22-i2v`'s `loras[]` pair map, triggers from
      the version API shown with their version id, `distribution: service`. The
      content rating is set from the live clip — `neutral` unless the clip shows
      the LoRA pulling toward nudity. One live clip.
- [ ] **E.03.08** Driving-clip library for Animate-2, SCAIL-2 and Uni3C: a
      bucket prefix and a manifest of reference clips (yoga flows, choreography,
      runway and street walks, camera moves) that Oshun owns or has cleared,
      each with a consent id, duration, frame rate, subject count and licence
      note, and a Studio picker that lists them. The manifest shape and picker
      are agent-actionable; the footage is a precondition. The manifest shape is
      chosen so T.12's motion library can share it.
- [ ] **E.03.09** Stylised identity hold: one `scail2-animate` clip driving a
      drawn character from a real clip and one `wan22-i2v` clip from an anime
      still, scored on whether the drawn look survives motion; the result goes
      into both workflows' notes. No new rows.

## E.04 Sets and wardrobe on Qwen-Image-Edit 2511 (SFW lane)

- [ ] **E.04.01** Native 2511 rows: Multiple Angles from
      `fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA` (0.30 GB, Apache-2.0; the
      Image-only Civitai re-upload 2300308 is not taken), Lightning 4-step and
      8-step bf16 from `lightx2v/Qwen-Image-Edit-2511-Lightning` (0.85 GB each,
      Apache-2.0), and Anyone Cosplay (Civitai 2435164 / 2738032, all four
      flags). Lightning becomes a `speed_mode` on `qwen-edit` and
      `qwen-edit-control` (the 20-step control path A.02.05 noted). One live
      still per LoRA and per speed mode.
- [ ] **E.04.02** Edit-2509-trained LoRAs, one compatibility render each on 2511
      before any enum offers them: Clothes Try On (1940532 / 2196278), Outfit
      Extractor (1940557 / 2196307) and Pose Transfer v2 (1959609 / 2221229),
      all four flags; Next Scene v2 (`lovis93/next-scene-qwen-image-lora-2509`,
      MIT); Relight (`dx8152/Qwen-Image-Edit-2509-Relight`) and Light Migration
      (`dx8152/Qwen-Edit-2509-Light-Migration`), Apache-2.0. A LoRA whose render
      does not perform its task on 2511 is recorded as incompatible with the
      render as evidence and its row removed; passing ones continue to E.04.03.
- [ ] **E.04.03** `qwen-edit` tasks: a `loras[]` input and task presets that
      fill the prompt form each LoRA was trained on — try-on (garment image plus
      person), outfit extraction, new angle (azimuth, elevation and distance
      enums over the 96 poses), next scene, relight, light migration (reference
      tone image), cosplay (design image plus person) and pose transfer (pose
      image plus person). `content_policy: sfw_only` stays. Cosplay and try-on
      designs must be Oshun-owned, which the preset notes state; people are
      covered by the consent registry. Validated; E.04.01 and E.04.02's renders
      are the live proof.
- [x] **E.04.04** Chain rule for plates across content policies: a still made by
      an `sfw_only` workflow whose licence has no acceptable-use clause
      (Qwen-Image, klein 4B, HiDream-O1) may feed an `adult_ok` workflow; an
      output of `ltx25-av` or `ltx23-av` may not, because the LTX-2.x
      acceptable-use policy binds outputs. A chain or job naming such an input
      is refused with a 4xx naming the rule before any lease or billing. Output
      provenance records the producing workflow, so the check reads a fact, not
      a filename. Route spec both ways. _2026-09-15, the rule is built and
      specified; stays open for the route wiring.
      `libs/isis/workflows/src/output-chain-policy.ts` reads the producing
      workflow's `models_required` against the model manifest and treats an
      output as bound when any of those licences carries an acceptable-use
      clause — which today is exactly the LTX-2.x rows — so the check reads a
      licence, not a filename. A model the manifest does not know counts as
      bound rather than free, and an input whose provenance names no producing
      workflow is refused with `output_provenance_missing`. Specs (7) run
      against the real catalog files and the real manifest: ltx25-av refused
      into an adult_ok consumer with the licence named, Qwen-Image, klein 4B and
      HiDream-O1 allowed, and no effect on an sfw_only consumer. What is left:
      calling it at submit and on each chain step in the generation API, with
      the route spec both ways._ _**Closed 2026-09-16: it is called at both.**
      `apps/isis/generation-api/src/services/output-chain-policy.service.ts`
      loads the volume manifest once (a manifest it cannot read stays **closed**
      — with no artifacts every model is unknown, which the library already
      treats as bound) and answers for one consuming and one producing workflow.
      **At submit**, `JobService.submit` calls it immediately after the
      content-policy gate and before the model-cache lease, so a refusal leaves
      no lease, no row and no outbox entry. The producing workflow is not
      guessed: an input that names an Isis output carries the producing job in
      its own URL (`/api/v1/outputs/<jobId>/<file>`), so the job is looked up
      and its workflow read off it with the executor's own override order. An
      input that is NOT an Isis output — an upload, an external URL, a data URI
      — has no producing workflow here and the rule does not apply to it; the
      rule is about what Isis made. **On each chain step**, the advancer answers
      it exactly where a RunPod output feeds a RunPod step, which was previously
      an early `return null` — no lane boundary is crossed there, but a licence
      boundary can be. **One real behaviour change:** an `adult_ok` step whose
      plate has no readable producing workflow is now refused
      `output_provenance_missing`, which three existing advancer fixtures
      tripped because they omitted a `workflowId` a job that actually rendered
      always has; the shared fixture now carries one and the provenance-missing
      case is its own named test. 17 service specs and 4 new advancer specs (25
      in that file), both ways: `ltx25-av` refused into `wan22-i2v` with the
      licence named, Qwen-Image / klein 4B / HiDream-O1 allowed, an `sfw_only`
      consumer untouched, and a non-Isis input never looked up. Evidence:
      `## E.04`._
- [ ] **E.04.05** Qwen-Image-Layered (tier 2, only on the user's go): rows for
      `qwen_image_layered_bf16` (40.86 GB) and its VAE (0.25 GB), Apache-2.0,
      with the text encoder shared with Qwen-Image where the oid matches, and a
      `qwen-layered-split` workflow in the `heavy-image` category that splits a
      set into RGBA layers (the latent node is already in the image). Stays
      `[ ]` with this note until the go; then validated and one live split.
      _2026-09-18, board tag: pulled only on the user's go, by this item's own
      wording._ `blocked:human`

## E.05 Look, detail and control for stills

- [ ] **E.05.01** Z-Image Turbo look LoRAs on the Turbo checkpoints' `loras[]`:
      AfterDark v2.0-ZIT (2176378 / 2470291, Image+RentCivit+Rent, trigger
      `4ft3rd4rk`), GrainScape UltraReal (1332651 / 2460872), Movie Wide Angle
      (2186574 / 2462010) and [ZIT] Light Slider (2262501 / 2546755, strength
      below zero darkens), each with all four flags except AfterDark, as
      `service`; Cinematic Shot ZIT (432586 / 2454927, Image+RentCivit) as
      `internal_only`. One live still each.
- [ ] **E.05.02** Detailer tail on `chroma-txt2img`, `chroma-img2img`,
      `zimage-txt2img` and `zimage-img2img`: an optional
      `detail: none | face | hands | face_and_hands` input that runs
      `SAM3_Detect` on the target, crops around each detection
      (`ImageCropToMask`, `CropByBBoxes`), inpaints the crop at a higher working
      resolution on the same checkpoint and LoRAs at a declared denoise, matches
      colour back (`ColorTransfer`) and composites (`ImageCompositeMasked`). A
      render with no detection records "nothing detected" in the job output
      rather than claiming a fix. With `detail: none` the render stays
      byte-identical to the goldens. One live still per workflow family.
- [ ] **E.05.03** `zimage-control-chroma-refine`: Z-Image with the Fun union
      patch (pose, depth through Depth Anything 3, canny) composes the image,
      and the latent passes without a decode into a Chroma checkpoint at a
      declared denoise (default 0.35) with the Chroma prompt and LoRAs. This
      relies on both families using the Flux `ae` (same LFS oid); a spec asserts
      both graphs load the one shared row, so validation fails if that ever
      changes. Validated, then one live still with a pose reference. C.12.03's
      finding stands.
- [ ] **E.05.04** Regional prompting (tier 2) on `zimage-txt2img`: up to three
      regions (subject, wardrobe, background), each with its own prompt through
      `ConditioningSetMask`, masks from an uploaded colour map or from SAM 3.1
      text prompts on an init image. Validated, then one live still.

## E.06 Stylised and anime lane

- [ ] **E.06.01** Adult-appearance gate before any stylised workflow or style
      option allows nudity: prompt screening for age terms and youth-coded
      descriptors, and an output age-appearance classifier with a documented
      licence and threshold, run on every output of a stylised workflow or style
      LoRA; a positive refuses delivery and records the job, and an unavailable
      classifier fails closed. Until the gate is live, every E.06 workflow and
      style option is `sfw_only` and the submit path refuses racy or explicit
      content on them (A.04.01's mechanism). The classifier choice is recorded
      in the register with its licence; false positives are measured on an adult
      stylised set, and false negatives are taken from the classifier's
      published evaluation — never by generating or collecting images of minors.
      Specs both ways; one chromium check that a refused output is not shown.
      Legal basis: Coroners and Justice Act 2009 s.62, which covers drawn
      images.
- [ ] **E.06.02** Style LoRA rows on bases Isis runs (all free, none in early
      access): Velvet's Mythic Fantasy Styles ZiT (599757: Detailed Anime
      2504197, Anime Lines 2466747, Gothic Lines 2924569, Realistic Fantasy
      2547883; all four flags); Anime Flat Style (1952560: Qwen 2512 2559263,
      ZiT Clean 2455064; all four); Flat Color Style (1132089: Z-Image base
      2637093, ZiT 2616765, Qwen 2143914; Image+RentCivit+Rent; the HiDream
      version targets HiDream-I1 and is not taken); Character Design Sheet ZiT
      (100435 / 2500612, all four); Dark Art Style (1380736: Chroma 2320313, ZiT
      2467722; Image+RentCivit+Rent); Retro Sci-fi 90s (912942: Chroma 2326231,
      ZiT 2463751; Image+RentCivit+Rent); Aesthetic Quality Modifiers (929497:
      ZiT 2622701, Qwen 2241189; Image+RentCivit+Rent); LTX-2.5 3D Animation
      (2895989 / 3273961, Image+RentCivit+Rent, trigger `3dsrx`, `sfw_only`
      under the LTX policy). The two Qwen versions trained before 2512 get a
      compatibility render first (E.04.02's rule). All `service`, content
      `neutral`, and `sfw_only` until E.06.01. One live still or clip each.
- [ ] **E.06.03** NetaYume Lumina v4 and an `anime/` catalog category on the
      image endpoint: a row for `NetaYume_v4_all_in_one.safetensors` (10.62 GB,
      Apache-2.0, `duongve/NetaYume-Lumina-Image-2.0` @ `69c29c44…`), the
      ComfyUI Lumina 2 template read before the graph, and `anime-txt2img` and
      `anime-img2img` with the prompt form the model card documents.
      `content_policy: sfw_only` until E.06.01, then `adult_ok` behind the gate
      only by a separate user decision. Validated, then one live still each,
      with VRAM measured at the default shape.
- [ ] **E.06.04** Illustrious XL v2.0, listed and not pulled: a register row for
      `OnomaAIResearch/Illustrious-XL-v2.0` @ `69459c1f…` (6.94 GB, CreativeML
      OpenRAIL-M) marked listed. It is pulled only if E.01.05 shows a stylised
      need that NetaYume and the style LoRAs cannot serve, and then only the
      OnomaAI base or a merge whose lineage is documented as free of NoobAI.
      Keep `[ ]` unless pulled. _2026-09-18, board tag: pulled only if E.01.05
      shows a stylised need the other lanes cannot serve._ `blocked:upstream`

## E.07 Licence register and exclusions

- [x] **E.07.01** Correct the Krea 2 / Kroma exclusion in
      `docs/domains/isis/runbooks/model-licences.md` and its source in
      `scripts/isis/model-licence-register.mjs`, from the verbatim v1 text: a
      revocable grant with termination for convenience on 30 days' notice
      (§9.2), and commercial use of the model, derivatives and outputs only
      below USD 1 000 000 company-wide trailing revenue including affiliates
      (§2.3). §4.2's filters target prohibited, harmful or unlawful content; the
      acceptable-use policy bans CSAM, non-consensual intimate imagery and
      rights violations, not adult nudity; the text has no seat cap. It stays
      excluded, for those two limits. The register test stays green. _**Done
      2026-09-15.** Re-read verbatim the same day: the Krea 2 Community License
      Agreement (dateModified 2026-06-22) at
      https://www.krea.ai/krea-2-licensing, where §2.3 limits commercial use of
      the model, derivatives and outputs to under USD 1 000 000 company-wide
      revenue on a trailing twelve-month basis, affiliates included, §4.2
      requires reasonable filters against prohibited, harmful or unlawful
      content, §9.2 allows termination for any reason on 30 days' notice, and no
      seat clause exists; and the acceptable use policy (2026-06-22) at
      https://www.krea.ai/krea-2-use-policy, which names CSAM and NCII, not
      consensual adult nudity. The exclusion row in
      `scripts/isis/model-licence-register.mjs` now gives those two limits as
      the reason and says content is not one. The register was regenerated (98
      rows), `--check` matches and the register test passes 5 of 5._
- [x] **E.07.02** Exclusion additions and rules: Pony V7 (no inference service,
      no company above USD 1M revenue, no professional video production),
      NoobAI-XL and merges of its lineage (no-commercialisation term),
      NewBie-image (`newbie-nc-1.0`), LoRAs imitating a named studio or a living
      artist (rights of publicity and trade marks, whatever the Civitai flags
      say), Civitai versions with a non-null `paidAccess` (never pulled) and
      early-access versions (deferred until the window ends). MiniMax H3 and the
      Hunyuan rows keep territory as the reason; Sulphur-2's reason becomes "no
      licence published". Register regenerated, test green. _**Done 2026-09-15,
      with one correction.** Re-read the same day: Pony V7's model card (the
      `LICENSE` file at af688af5 is empty, so the README summary is the only
      text), NoobAI-XL 1.1's card (FAIPL-1.0-SD plus "Commercial Prohibition"),
      NewBie-image's `newbie-nc-1.0` tag. Sulphur-2's reason did **not** become
      "no licence published", because that is false: `SulphurAI/Sulphur-2-base`
      has carried the LTX-2 Community License Agreement (2026-01-05) as
      `LICENSE.txt` since 2026-05-08 and ships bf16 checkpoints, so the survey's
      "no licence, int8-only ports" was wrong too. It stays excluded because
      Attachment A binds outputs to the Lightricks acceptable use policy, which
      defeats its uncensoring purpose, and LTX-2.3 is retired. Civitai access is
      split by the API's own field: a permanent `paidAccess` is never pulled;
      one with a future `endsAt` is early access, deferred. The register was
      regenerated, `--check` matches, and the test passes 5 of 5._
- [ ] **E.07.03** A register row for every E addition in the same commit as its
      manifest row (A.04.04's rule), including E.03.01's provenance note and
      E.06.01's classifier; the existing spec checks each new checkpoint and
      LoRA option's `option_policy` flags against the manifest licence strings.

## E.08 Closure

- [ ] **E.08.01** Close the extension: every E item checked or carrying a dated
      note naming its one blocker; the library and the cache read back (totals,
      pinned closure, families) against the manifest; retirements and the
      bake-off deletion confirmed by listing; the footprint table replaced by
      measured figures; evidence `## E.08` with the before and after inventory;
      this tracker's state notes updated; memory note written.

# Hosted image and video lane (H.00–H.07) — OpenRouter beside RunPod (added 2026-09-15)

## Facts verified on 2026-09-15 for the hosted lane (OpenRouter API with the project key, OpenRouter docs and terms; re-verify before relying)

- **Image API:** `POST https://openrouter.ai/api/v1/images` takes `model`,
  `prompt` and, per model, `aspect_ratio`, `resolution`, `size`, `quality`,
  `output_format`, `background`, `output_compression`, `seed`, `n` and
  `input_references` (http(s) or base64 data URLs, for editing). The response
  carries `data[].b64_json` with `media_type`, and `usage` with cost in USD;
  streaming is SSE (`image_generation.partial_image`,
  `image_generation.completed`, `error`). Billing: a generation "is either
  completed and billed in full, or it fails and is not billed". The catalog is
  `GET /api/v1/images/models` (52 models on 2026-09-15). Each model lists
  `supported_parameters` as enum, range or boolean descriptors, and
  `/api/v1/images/models/{id}/endpoints` gives per-provider pricing (for example
  `black-forest-labs/flux.2-klein-4b`: 0.014 USD per output megapixel, `n` 1, up
  to 4 references, passthrough `steps`, `guidance`, `safety_tolerance`). Image
  entries carry no `canonical_slug`.
- **Video API:** `POST /api/v1/videos` (202 with `id`, `polling_url`, `status`
  pending), `GET /api/v1/videos/{id}`
  (`pending | in_progress | completed | failed`, `generation_id`,
  `unsigned_urls`, `usage.cost`, `usage.is_byok`),
  `GET /api/v1/videos/{id}/content?index=0` with the key. Request fields:
  `duration`, `resolution`, `aspect_ratio`, `size`, `frame_images`
  (`first_frame` or `last_frame`), `input_references`, `generate_audio` (default
  true where supported), `seed`, `provider.options` passthrough, `callback_url`
  (HTTPS). Webhooks sign `X-OpenRouter-Signature: t=<ts>,v1=<hmac>` over
  `<ts>,<raw body>`, with a 5-minute replay window; the events are
  `video.generation.completed | failed | cancelled | expired`. The guide
  suggests polling every 30 s. Video is not eligible for zero data retention.
  The catalog is `GET /api/v1/videos/models` (29 models, each with a dated
  `canonical_slug`, supported durations, resolutions, aspect ratios, sizes and
  frame images, `generate_audio`, `seed`, heterogeneous `pricing_skus` and
  `allowed_passthrough_parameters`). Examples of cheap SKUs: `alibaba/wan-3.0`
  0.05 USD/s at 480p, `bytedance/seedance-2.0-mini` 0.0000035 USD per video
  token, `google/veo-3.1-lite` 0.03 USD/s at 720p without audio.
- **Terms** (https://openrouter.ai/terms, "Last Updated: August 31, 2026"): 7(4)
  forbids reselling API access to models or developing a competing service; 5.1
  and 7(8) bind the customer to each model's and provider's own terms; 6.1
  leaves output ownership to those model terms and notes that some models train
  on inputs.
- **Account:** 50 USD of credits, 21.75 USD used (28.25 USD left) on 2026-09-15.
- **Existing code:**
  `apps/oshun/bff/src/generation/openrouter-video-provider.ts` (phase 182)
  already calls the video API for Oshun; `@isis/seedance-provider` holds fal,
  PiAPI and Ark Seedance clients; the Meshy lane
  (`libs/isis/workflows/src/three-d-capabilities/hosted-lane-policy.ts`,
  `apps/isis/generation-api/src/services/meshy-lane/`) is the pattern to follow.

## Hosted lane design decisions (defaults chosen 2026-09-15; each is one line to flip)

1. **Hosted calls run from the generation API, not inside the ComfyUI worker.**
   ComfyUI's partner API nodes would bill RunPod GPU seconds while a vendor
   renders and would put the vendor key into the worker environment. A chain
   that mixes lanes gets the same result: a hosted still into `wan22-i2v`, a
   Chroma still into a hosted image-to-video model, a hosted clip into the
   SeedVR2 upscaler.
2. **Every hosted workflow is `content_policy: sfw_only`.** The upstream
   providers' acceptable-use terms bind inputs (terms 7(8)). Adult work never
   leaves RunPod, and a racy or explicit RunPod output is never sent to a hosted
   step.
3. **The lane is chosen per job, and RunPod-only reasons are computed.** A job
   names `lane`. The API refuses a hosted lane for a job that needs RunPod
   (`adult_ok`, LoRAs, control maps, masks, internal-only options, a custom
   graph) and names the reason. Nothing silently switches lanes, and a workspace
   preference only pre-selects.
4. **Operator only until the owner decides tenant exposure** (H.00.02), for the
   same reselling question T.22.01 settled for Meshy.
5. **Cost is what OpenRouter reports.** `usage.cost` is the actual; the endpoint
   pricing is only the pre-submit estimate. A shape that cannot be priced is
   refused, not guessed.
6. **Proofs use cheap models first.** Frontier vendors (OpenAI, Google) are not
   proof inputs without asking (repository cost rule).

## H.00 Policy, model terms and phase control

- [x] **H.00.01** Model terms register for the hosted lane: one row per offered
      OpenRouter image or video model with the model provider's terms (URL, read
      date, sha256), output ownership, acceptable-use rules, territory (the UK
      must be served), whether the provider trains on inputs, and the derived
      policy (always `sfw_only`; tenant exposure; whether outputs may feed an
      `adult_ok` workflow, E.04.04's rule). Models whose terms cannot be read,
      or that exclude the UK or commercial output use, are listed as excluded
      with the reason. **Verify:** a spec fails when an offered model has no
      register row, and a model new in the catalog is unreviewed, not offered.
      _2026-09-15, built; stays open until the catalog offers what it admits.
      `libs/isis/workflows/src/hosted-media/openrouter-model-register.ts` holds
      one row per model with the vendor terms that were read, what they leave
      open, and the derived policy (sfw_only, operator-internal, never an input
      to an `adult_ok` workflow). Offered today: the FLUX.2 family (klein 4B,
      flex, pro) under Black Forest Labs' terms of 2026-08-01. Excluded with
      reasons: OpenAI (terms answered 403), Alibaba Wan (Model Studio terms 404
      and Article 4.48 not served), Krea 2 and MiniMax H3 (already excluded for
      the weights), and Google's image and video models — read, but the owner's
      proof approval excludes frontier vendors, so offering them needs an owner
      decision. **No video model is offered yet** and the register says why. A
      model the live catalog gains is unreviewed, which the policy refuses. 33
      specs._ _**2026-09-16, the stated blocker lifted but a different one is
      real.** The catalog now offers exactly what the register admits (the six
      `openrouter:<task>:<model>` entries are generated from it), so that reason
      is gone. What the item asks for and the register still lacks: **a sha256
      of each terms document**, so a vendor quietly rewriting its terms is
      detectable rather than trusted; and **territory (the UK must be served)
      and whether the vendor trains on inputs are prose inside `findings` and
      `openQuestions`, not fields a spec can check**. Both are additions to
      `OpenRouterVendorTerms` plus a fetch-and-hash step; neither is blocked by
      anything outside this repository._ _**Closed 2026-09-16.**
      `OpenRouterVendorTerms` gained `unitedKingdom` and `trainsOnInputs` — a
      verdict plus the clause it rests on — and `openRouterRegisterProblems()`
      refuses to offer a model whose UK verdict is anything but `served` or
      `not_excluded`. BFL reads `not_excluded` (12.1 export controls are its
      only territory clause) and `opt_out_held_by_openrouter` (1.2(e)'s opt-out
      belongs to OpenRouter, not Isis); Google reads `conditional` — UK users on
      Paid Services only, and Isis cannot see which tier OpenRouter buys — which
      is now a second, independent reason its rows are excluded. Re-reading BFL
      in full found two clauses the first reading missed: **1.3(n)** forbids
      using Output to "train, distill or fine-tune any other AI models" (this
      binds E.01.07), and **1.3(p)** forbids obscuring AI content marking, so
      the watermark and C2PA stages are a vendor requirement and not only Isis
      policy. The fingerprint is `textSha256` over a named normalization
      (`isis-terms-text-v1`) rather than the response bytes, and the reason was
      measured: two fetches a minute apart returned byte-identical BFL bodies
      but two different Google bodies, differing in 3 149 bytes that are all
      per-request CSP nonces — a raw hash would cry drift on a document nobody
      touched. `rawSha256` is kept beside it with a measured `rawStable` flag.
      `libs/isis/workflows/scripts/openrouter-terms-drift.ts --check` (offline,
      wired into the lib's `lint` through `hosted-terms:check`) re-hashes the
      checked-in normalized copies under
      `docs/agents/evidence/isis-chroma-runpod/h0001/` and was verified to fail
      on a tampered clause; `--check-remote` ran live and reported BFL unchanged
      and Google cosmetic-only; `--write` deliberately refuses to edit the
      register, because a new hash without a person re-reading the clauses is a
      machine re-approving terms nobody read. It cannot tell a reworded clause
      from a reformatted page — both end with a person re-reading the document.
      12 + 14 specs, seven of them negative. Evidence: H.00.01._
- [x] **H.00.02** Owner decision on tenant exposure under OpenRouter terms 7(4)
      and each model's terms, recorded with its date and source; until then the
      checked-in default is operator only. **Verify:** the policy specs refuse a
      tenant at submit, chain step, retry and in the catalog while the default
      stands. _**Decided 2026-09-15.** Asked and answered in this session:
      "Operator only for now". `OPENROUTER_LANE_TENANT_EXPOSURE` carries the
      decision, its date and its source, and `evaluateOpenRouterLaneRequest`
      refuses a non-operator with 403 whatever the request claims. **Closed
      2026-09-16:** the routes call it. `JobService.submit` runs
      `assertOpenRouterLaneSubmittable` (so retry, which re-submits, is judged
      with the retrying caller's tenant), `POST /jobs/chain` judges every step
      before any lease, the runner judges the stored job again before any HTTP
      call, and `/workflows/catalog` and `/workflows/hosted-lanes/openrouter`
      show a non-operator nothing and answer 403. 20 route specs._
- [x] **H.00.03** Evidence: `docs/agents/isis-chroma-runpod-evidence.md` gains
      `## H.00`–`## H.07`. Every live hosted job records the OpenRouter job or
      generation id, `usage.cost`, wall time and the output hash. Estimate and
      ask before spending. _2026-09-16. The evidence file carries `## H.00` (the
      gate, the register, the exposure decision), `## H.01` (the one client, the
      snapshot, the BFF move), `## H.02–H.05` (the API and the Studio),
      `## H.06.01` (two live jobs with their ids, costs, wall times and output
      hashes, and the two defects the first one found) and `## H.06.02` (the
      mixed-lane attempt, its two blockers and the three defects it found).
      Spend was estimated and approved before each round: 0.043 USD of 0.6
      OpenRouter, and the RunPod half was refused by its own budget gate rather
      than exceeded._

## H.01 One OpenRouter media client

- [x] **H.01.01** A typed OpenRouter media client in `@isis/ai-providers`
      (`providers/openrouter-media`): image create (plain and SSE), video
      create, get, content download and the webhook signature check with the
      replay window, both model catalogs with per-endpoint pricing, typed errors
      (insufficient credits, rate limit, moderation or provider refusal,
      unsupported parameter, expired), and `OPENROUTER_API_KEY` read through
      `@oshun/config`. **Verify:** client specs against recorded response
      shapes; no production file reads `process.env`. _2026-09-15.
      `libs/isis/ai-providers/src/providers/openrouter-media/`: `client.ts`
      (image create buffered and SSE, video create / get / wait / content
      download, both catalogues, `ensureVideo` which never re-creates a recorded
      job), `errors.ts` (one class per documented failure), `pricing.ts`,
      `outputs.ts`, `capabilities.ts`, `webhooks.ts` (signature over the RAW
      body, five-minute replay window both directions, constant-time compare,
      `@noble/hashes` because `node:crypto` is banned in client-transpiled
      libs). The key is injected —
      `createOpenRouterMediaClient(getOpenRouterMediaConfig())` — and a grep for
      `process.env` over the production files is empty. 38 client specs, 47
      support specs. Two things the client learned from use on 2026-09-16: an
      optional poll backoff (`pollBackoffFactor`, `maxPollIntervalMs`, default
      the documented fixed cadence) and `describeJobError`, so a failed job's
      reason reaches the message instead of `[object Object]`._
- [x] **H.01.02** Catalog snapshot and drift check: a checked-in snapshot of
      `/images/models`, `/videos/models` and the endpoint pricing of offered
      models, with the fetch date; a spec that fails when an offered workflow
      names a model or parameter the snapshot does not support; a
      `--check-remote` report that names added, removed and repriced models.
      **Verify:** the spec passes on the snapshot and fails on a fixture that
      removes a parameter. _2026-09-15. `openrouter-media-surface.snapshot.json`
      (fetched 2026-09-15) holds both catalogues and the offered models'
      endpoint pricing; `surface.ts` compares it with what the client and the
      register name, and the negative cases are real: "fails when a named model
      or parameter is not in the snapshot", "fails in both directions when the
      client and the catalogue describe different parameters", "fails when the
      client calls a route the snapshot does not list". the surface script's
      `--check` runs it offline; `--check-remote` re-fetches and names added,
      removed and repriced models._
- [x] **H.01.03** One OpenRouter video client in the repository: Oshun's
      `apps/oshun/bff/src/generation/openrouter-video-provider.ts` moves onto
      the H.01.01 client, or the reason it cannot is recorded. **Verify:** its
      callers' specs pass. _**Moved 2026-09-16.** It could move: `scope:oshun`
      may depend on `scope:isis` (the boundary rule already lists it), and the
      BFF already declares `@isis/ai-providers`. the BFF's
      `openrouter-video-provider.ts` is now an adapter over the shared client —
      its own poll loop, its own resolution and aspect-ratio tables and its own
      HTTP error strings are gone (364 → 271 lines, half of them the note that
      says where the contract now lives), and what it keeps is Oshun's own
      policy: integer seconds, the first-frame reference, and the data: URI the
      watermark, C2PA and ffprobe stages need bytes from. Three things it gains:
      the key is not sent to a content URL off the API host, failures arrive
      typed, and a transient poll failure no longer abandons a job that is
      running and billing. Its 16 specs pass at the new boundary (`fetch` →
      `Response`, a clock that advances with the injected sleeps),
      `video-hero-gate` 3, `video-executor` 12 and `video-provider-env` 20 pass
      unchanged, and `tsc --noEmit` on the BFF is clean. The route's admission
      is unchanged: it stays behind
      `isEveExtendedProviderAdmitted('video-openrouter')`, and sharing a
      transport grants it nothing — the 2026-09-15 attestation covers
      operator-only Isis traffic, and the Isis register offers no video model._

## H.02 Hosted workflows and lane selection

- [x] **H.02.01** Hosted catalog entries generated from the snapshot and the
      register: tasks `txt2img`, `img-edit`, `t2v`, `i2v`, `flf2v`, `video-edit`
      and `video-upscale`, with each model's inputs taken from its supported
      parameters (aspect ratio, resolution or size, seed, `n`, quality,
      reference count, output format and background; for video, duration, frame
      images and audio). Each entry is `lane: openrouter`, `sfw_only`,
      `proof_level: validated`. **Verify:** catalog spec; a parameter the model
      does not list is refused at submit with 422. _2026-09-16.
      `openrouter-lane-catalog.ts` builds one entry per offered model × task,
      its parameters read from the checked-in snapshot rather than hand-typed,
      beside the vendor terms the row rests on.
      `GET /workflows/hosted-lanes/openrouter` serves the listing and
      `/workflows/catalog` carries `openRouterLanes` (empty for a non-operator).
      The 422 is real and costs nothing: `checkImageRequestAgainstCatalogue`
      runs against the snapshot endpoint record at submit, so a parameter the
      model does not list is refused before any call, naming the allowed values.
      Video tasks are refused 422 naming `OPENROUTER_VIDEO_BLOCKER` rather than
      a model mismatch that would hide the reason._
- [x] **H.02.02** Lane selection: an equivalence map from each task to the
      RunPod workflows and hosted models that serve it; job submit and chain
      steps accept `lane: runpod | openrouter | meshy`; a hosted lane is refused
      for an `adult_ok` workflow, LoRAs, control maps, masks, internal-only
      options or a custom graph, with the RunPod-only reason in the response.
      **Verify:** route spec both ways, including a retry that keeps its lane.
      _2026-09-16, partly. The equivalence map is checked against the real
      catalog (`OPENROUTER_TASK_EQUIVALENCE`; a spec asserts every id it names
      exists), and the lane a job runs on is the workflow id it names:
      `openrouter:` dispatches to the OpenRouter runner, `meshy:` to the Meshy
      runner, anything else to the ComfyUI resolver — all before any GPU lease.
      A retry keeps its lane because it re-submits the same workflow id and is
      judged again. A request that names the hosted lane but carries work only a
      ComfyUI graph can do — a LoRA, a control map, a mask, a custom graph or an
      `adult_ok` policy — is refused `hosted_lane_runpod_only` 422 carrying
      `runpodOnlyReasons()` and the self-hosted workflows that serve the same
      task, so the answer says where the job CAN run. Those fields have nowhere
      to go in a hosted request, and a dropped field is a silent wrong render.
      25 route specs._

## H.03 Execution, outputs and cost

- [x] **H.03.01** Executor: hosted jobs run from the generation API with no GPU
      lease; video is completed by webhook when the API has a public URL and
      polled every 30 s otherwise; the OpenRouter job id is recorded before the
      first poll so a retry or recovery resumes it. Outputs (`b64_json` or the
      content endpoint) persist byte-identical in the Hetzner outputs store,
      with provenance naming the lane, model, upstream provider, generation id,
      cost and consents, and go through the same watermark and provenance stages
      as RunPod outputs. **Verify:** executor specs with the HTTP boundary
      mocked, covering resume without a second job, a failed job recorded as
      unbilled, and an expired job. _2026-09-16, for the image half — which is
      the whole lane, because no video model is offered (H.00.01), so there is
      no webhook or poll path to build. A job naming an `openrouter:` workflow
      id runs in `executeOpenRouterLane` with no GPU lease, and the three
      verification cases are specs: resume (a recorded generation with stored
      outputs returns unchanged, no call and no second booking), a failed
      generation (nothing in the ledger, no dispatch record), and the case the
      image route creates instead of an expiry — a recorded generation whose
      bytes were never stored **fails loudly and non-retryably**, because
      OpenRouter's image answer is synchronous, "either completed and billed in
      full, or it fails and is not billed", and it publishes no route that reads
      a finished image back. Paying twice is a decision for a person, not for a
      retry. The generation id is minted (`img-<job id>-<created>`) and its
      source recorded in provenance beside it, since the documented answer
      carries none; it is written down through `onProviderDispatch` before
      anything touches the bytes, and with no recorder attached the lane refuses
      to create at all. Outputs persist byte for byte (the stored sha256 must
      equal the sha256 of the decoded bytes) with provenance naming the lane,
      model, upstream provider, generation id, estimate, actual, both consent
      ids and the vendor terms. 16 runner specs, 20 route specs._
- [x] **H.03.02** Cost ledger for the lane: a pre-submit estimate from endpoint
      pricing (refused when the SKU cannot be priced for the requested shape),
      the actual cost from `usage.cost`, a daily budget that fails closed, and
      the cost shown in Jobs and the ledger beside RunPod and Meshy. **Verify:**
      ledger spec with the budget edge and an unpriceable shape. _2026-09-16,
      the API half. The estimate comes from the snapshot endpoint record, a
      shape the catalogue cannot price is refused before any call
      (`OpenRouterPricingUnknownError`, never a guessed megapixel count), the
      actual is `usage.cost` booked once per generation id, and the daily gate
      runs twice — at submit (`refuseIfOverOpenRouterDailyBudget`, 429 over
      budget, 503 when Redis is unreachable, with the spend headers) and again
      in the runner before it creates. An answer that reports no `usage.cost`
      books nothing and says so in provenance, because "no cost reported" and
      "cost zero" are different claims. 6 ledger specs plus the budget and
      unpriceable cases in the runner specs. Proved live 2026-09-16 (H.06.01):
      two generations booked 0.014 and 0.015 USD against estimates of 0.01468,
      and the submit headers read `x-openrouter-daily-spend-usd: 0.043`,
      `x-openrouter-daily-remaining-usd: 0.557` against the 0.6 cap. **Closed
      2026-09-16:** the Studio's hosted panel shows the pre-submit estimate
      (from the API's own estimate route, never computed in the browser) and,
      after the job, `output.metadata.costUsd` beside the estimate it was
      weighed against — RunPod seconds, Meshy credits and OpenRouter dollars
      each read from the lane that booked them._

## H.04 Mixed-lane chains

_2026-09-15, the ledger half is built:
`apps/isis/generation-api/src/services/openrouter-lane/openrouter-cost-ledger.service.ts`
books `usage.cost` — the dollars OpenRouter reports — once per generation id,
with per-model totals, a daily budget checked against the catalog estimate
(`ISIS_OPENROUTER_DAILY_BUDGET_USD`, default 2), and fail-closed behaviour when
Redis is unreachable. 6 specs. Stays open for the executor that feeds it and the
Jobs-page line._

- [ ] **H.04.01** Chain steps may run on any lane: hosted to RunPod (a hosted
      still into `wan22-i2v`, a hosted clip into SeedVR2) and RunPod to hosted
      (a Chroma still into a hosted image-to-video model). A hosted step refuses
      a racy or explicit input by provenance, and an `adult_ok` step refuses the
      output of a hosted model whose terms bind outputs, each with a 4xx naming
      the rule before any lease or billing. **Verify:** chain specs both ways
      with the HTTP boundary mocked. _2026-09-16. The chain rule is wired where
      the chain actually advances: `advanceChain` gained a `checkPolicy` hook
      judged **before** the budget — a step that must not run is not weighed
      against money — and the advancer answers it from what provenance records.
      A hosted output feeding an `adult_ok` workflow is stopped
      (`HOSTED_LANE_OUTPUT_POLICY`): every offered model's register row says its
      outputs may not, so **a hosted still may not feed `wan22-i2v`**, which is
      declared `adult_ok`. The sfw_only motion workflow `ltx25-av` takes one.
      Material whose rating is neither recorded nor declared is refused before
      it reaches a vendor (`HOSTED_LANE_INPUT_RATING_UNKNOWN`) — an unreadable
      rating is not a neutral one — and a declared `racy` input is refused
      (`CONTENT_POLICY_VIOLATION`). 6 advancer specs. **Open:** no content
      rating is persisted on a RunPod output, so a hosted step still depends on
      the chain declaring `inputs.hostedLane.inputContentRatings`; recording the
      submit-time judgement on the output belongs to A.04. RunPod → hosted for
      the video direction cannot exist at all while no video model is offered._
      _**2026-09-16, the first of those two is closed; one blocker left.** A
      RunPod output now carries the judgement its own submit made.
      `judgeSubmitContentRating` (in `@isis/workflows`, beside
      `evaluateContentPolicy`) answers three ways and `unknown` is one of them:
      an `sfw_only` workflow is rated **neutral** because the submit gate
      refuses any racy or explicit option or preset, so reaching the recording
      is itself the evidence; anything selecting a weight or preset rated racy
      or explicit takes **that** rating, most restrictive first; and an
      `adult_ok` workflow that nothing rated stays **unknown**, because the
      prompt is unconstrained and guessing neutral there is exactly what the
      chain rule exists to prevent. `judgeSubmitContent` stamps it on the job in
      `JobService.submit`, immediately after the gate; the advancer reads it
      from the producing job and it **outranks**
      `inputs.hostedLane.     inputContentRatings`, because a declaration is the
      caller's claim about material the caller did not make. A rating this build
      does not know reads back as no rating at all. So a Chroma still (adult_ok,
      unrated) is still refused without a declaration — correctly — while an
      `ltx25-av` or `klein4b` output now crosses to a hosted step on its own
      record. 6 lib specs, 6 API specs, 5 new advancer specs (21 in that file).
      **The one blocker left is unchanged and external:** RunPod → hosted in the
      video direction cannot exist while no video vendor's terms can be read
      (`OPENROUTER_VIDEO_BLOCKER`), so the item stays open on that alone._
      _2026-09-18, board tag: the one blocker left is that no video vendor's
      terms can be read (`OPENROUTER_VIDEO_BLOCKER`)._ `blocked:external`

## H.05 Studio

- [x] **H.05.01** Jobs page: a lane picker (RunPod, OpenRouter, Meshy) with the
      model list for the task, a parameter form from the catalog, the estimate
      before submit and the measured cost after, the RunPod-only reason when a
      hosted lane is refused, and refusals shown as errors. **Verify:** a
      chromium Playwright check of the picker, one refusal and one cost line.
      _2026-09-16. `apps/isis/web/src/components/HostedLanePanel.tsx` with its
      readers in `src/pages/hosted-lane-utils.ts`: the picker offers only the
      lanes the catalog actually served this caller — an empty `openRouterLanes`
      is the answer, not a loading state, so a tenant sees no hosted lane rather
      than a picker that would only earn a 403. The parameter form is one
      control per catalog-snapshot descriptor, and a descriptor it cannot render
      honestly says so instead of guessing a wire type. Refusals show as errors,
      and `hosted_lane_runpod_only` prints its reasons beside the self-hosted
      workflows that serve the task. The estimate is not computed in the
      browser: a new operator-only
      `POST /workflows/hosted-lanes/openrouter/estimate` runs the same
      arithmetic as the submit-time budget gate and creates and books nothing,
      and an unpriceable shape paints what is missing where the number would go.
      The measured cost after the job is `output.metadata.costUsd`, beside the
      estimate it was weighed against. The Meshy half is thinner on purpose: the
      catalog publishes no per-parameter descriptors for Meshy modes, so the
      panel says so and takes the body as JSON rather than inventing controls.
      128 specs plus 3 chromium Playwright specs (picker, refusal, cost line),
      all green; servers and browsers torn down after._

## H.06 Live proof

- [x] **H.06.01** One live hosted job per task group through the API as the
      operator, on cheap models: text to image, image edit with a reference,
      text to video and image to video (and first-last frame where the chosen
      model supports it), each with its id, `usage.cost`, wall time and output
      checks (decodes, dimensions, duration, audio present when requested). Ask
      before spending. **Verify:** evidence per group; nothing marked rendered
      without an id and a reported cost. _**Done 2026-09-16 for both groups that
      exist, 0.043 USD of the 0.6 approved.** Text to image: job `05bfced8`,
      flux.2-klein-4b, 0.014 USD actual against a 0.01468 estimate, 6.9 s, PNG
      1024×1024 1 485 838 B sha256 `3d6bdf6cd20694dd…`. Image edit with the
      first image as its only (operator-owned) reference: job `1d8db4d0`, 0.015
      USD, 16.0 s, PNG 1024×1024 1 411 737 B `22ff1732433075a6…` — same table,
      framing and light, green enamel shade and a fern, which is what was asked
      and nothing more. Both carry a provenance bundle and the lane's own
      generation id. **The two video groups could not run**: no video model is
      offered, and the API says so live — 422 `hosted_lane_video_unavailable`
      naming the blocker. Ledger read live: spend 0.043, remaining 0.557 of the
      pinned 0.6 cap. Two defects the live run found and fixed: a null
      `modelVersion` failed the provenance bundle **after** a generation had
      been created and billed (image models publish no version; the model id
      stands in with its source recorded), and the bundle was overwriting the
      lane's generation id (recorded as `laneGenerationId` now). Evidence:
      `docs/agents/isis-chroma-runpod-evidence.md` H.06.01._
- [ ] **H.06.02** One mixed-lane chain live: a hosted still into `wan22-i2v` on
      RunPod, or a Chroma still into a hosted image-to-video model, with both
      steps' costs on one chain. Ask before spending. **Verify:** evidence with
      both ids. _**Attempted live 2026-09-16, blocked, blockers named.** The
      chain half works: `POST /jobs/chain` took a hosted `txt2img` step followed
      by `ltx25-av`, the still was created (0.014 USD) and stored, and the chain
      advanced and handed the RunPod step that still. Two blockers stop the
      second half. **(1) The volume input channel does not resolve on the live
      workers.** `entry.sh` links `/comfyui/input/volume` to
      `/runpod-volume/inputs` (the worker's own start-up log says so), both
      endpoints mount volume `5bst2pgw7y`, and the RunPod S3 API writes to that
      volume and reads the object back — yet ComfyUI answered an
      invalid-image-file error for a nested path, a one-level path and a flat
      one, on the image endpoint as well as the video one. The cause is not
      isolated; the next step is a shell on a worker. **(2) Budget.** The
      cheapest `ltx25-av` shape the catalog accepts estimates 0.7259 USD, above
      the ~0.5 the owner approved for RunPod this round, so the video budget
      gate refused before dispatch — the gate doing its job. Three real defects
      the attempt found and fixed: `workerPathForOutput` minted
      `volume/<jobId>/<name>` for objects under `outputs/`, a path no symlink
      reaches; an output the store WRITES to the volume carried no volume key at
      all; and one transient S3 answer lost an already-billed generation, so a
      paid-for write is now retried three times before it is called lost._

## H.07 Closure

- [x] **H.07.01** Close the lane: every H item checked or carrying a dated note
      naming its one blocker; the drift check re-run; E.01.04's SFW API
      reference re-pointed at this lane or the reason it stays on
      `@isis/seedance-provider` recorded; the tracker state updated; memory note
      written. _2026-09-16. Thirteen of the fifteen H items are checked, after
      H.00.01 closed later the same day; the "fourteen of fifteen" first written
      here was a miscount of the same two open items. The two that are not
      closed carry their blockers: **H.04.01** is wired for everything
      provenance records and names its one gap (no content rating is persisted
      on a RunPod output, so a hosted step depends on the chain declaring
      `inputs.hostedLane.inputContentRatings`; recording the submit-time
      judgement belongs to A.04), and **H.06.02** names two (the volume input
      channel does not resolve on the live workers; the cheapest video shape
      estimates above the approved spend). The drift check was re-run offline
      and is clean. E.01.04 stays on `@isis/seedance-provider` for now: this
      lane offers no video model at all, so re-pointing an SFW video reference
      at it would point it at a refusal._

# Film studio in Blender (F.00–F.20) — agentic film making across every department (added 2026-09-18)

Owner request, 2026-09-18: "there has been a lot of talk of gpt 6 astra being
really good at blender … research all these new developments, sota and industry
leading approaches as of today … ensure we have … tasks to implement the full
potential of applying this technology to every aspect of film making in
blender."

The T-track builds assets and one scene at a time: a mesh, a rig, a clip, a
scene with a timeline, a deterministic render. Nothing in this file yet makes a
**film** out of them. A search of this tracker on 2026-09-18 found no mention of
a storyboard, an animatic, previs, a sequencer, OpenTimelineIO, a compositor,
OpenEXR, Cryptomatte, ACES or OpenColorIO, a render farm, foley or a mix. The F
sections add the production on top of the T-track and wire the agent layer
(T.08, T.19–T.21) into every department, from the screenplay to the delivered
master. All F items are new and unchecked. No software was installed, no model
was called and no money was spent by this planning change.

**The presentation center already maps this track** (owner request, 2026-09-18).
`docs/presentations/presentation-center/EVE-V1-REDESIGN-TODOS.md` carries a
"Film studio in Blender" track of eleven gated chapters and 105 slides in which
every F item names the slide that will teach it (F.00.01 and F.20.08 are
recorded as bookkeeping). Whoever adds, splits or renumbers an F item adds it to
that track in the same commit, because the plan's automated crosswalk check does
not exist yet and the plan has fallen behind this tracker once before. A slide
is authored only after the items it names are checked.

## Decision taken by the user on 2026-09-18 (Astra runs on the Codex subscription only)

"gpt 6 astra should only be used through a codex subscription via codex cli or
codex cli exec or other appropriate and legal means but never through direct api
calls and billing".

What follows from it, binding on every F item and on T.08.03:

- **One route.** Astra is reached through the Codex CLI signed in with ChatGPT
  (`codex exec` for unattended work), on the subscription's included allowance.
  The OpenAI API, OpenRouter's `openai/gpt-6-astra*` listings, a `CODEX_API_KEY`
  or `OPENAI_API_KEY` in the child environment, and credits bought once the
  allowance runs out are all metered billing and all refused.
- **Out of allowance means stop.** The lane reports the limit and the reset
  time. It never falls back to a billed route and never buys credits.
- **Operator side only.** A subscription is the owner's own seat. Astra through
  Codex is a builder-side tool, as Eve's Codex agent is; it is never the runtime
  behind a tenant's request. F.01.01 reads the terms that govern this before the
  lane runs unattended.
- **The precedent is `tools/eve-codex-agent.mjs`.** Codex acts only through an
  MCP server the repository owns, in `workspace-write` at most and never
  `danger-full-access`, with secrets in a per-run 0600 profile and never on the
  command line. F.01.08 builds the film equivalent; until it exists, Astra
  through Codex stays the read-only consultant that `CLAUDE.md` already allows.
- **Every other model is unchanged.** The cheap harness binding and any
  OpenRouter-billed candidate stay under the existing cost rules and the owner's
  spend approval.

## Facts verified on 2026-09-18 for the film track (OpenRouter live catalog, OpenAI model and Codex documentation, the local Codex CLI, Blender release notes and Lab page, arXiv abstracts, the local Blender build; re-verify before relying)

Primary means read from the vendor's or project's own page on 2026-09-18.
Secondary means a third party reported it; F.00.04 replaces or strikes every
secondary figure before anything depends on it.

- **GPT-6 Astra exists and was released on 2026-09-03** (secondary for the date:
  [Axios](https://www.axios.com/2026/09/03/openai-astra-gpt-6-agi-brockman)).
  OpenAI's own announcement
  ([openai.com/index/gpt-6-astra](https://openai.com/index/gpt-6-astra/))
  answered HTTP 403 to the fetcher, as OpenAI's terms did for H.00.01, so its
  text is unread.
- **Model card, primary**
  ([OpenAI model documentation](https://developers.openai.com/api/docs/models/gpt-6-astra)):
  id `gpt-6-astra`, one snapshot; a context of 1.05 million tokens, of which
  0.922 million may be input and 0.128 million output; input text and image,
  **output text only, no video and no audio input**; reasoning efforts low,
  medium, high, xhigh and max; tools: computer use, code interpreter, MCP,
  hosted shell, image generation, apply_patch, web search, file search; endpoint
  `v1/responses`; knowledge cutoff **2026-04-30**. Price per million tokens: 10
  USD input, 1 USD cached input, 12.50 USD cache write, 50 USD output; a prompt
  over 272 000 input tokens is priced at 2x input and cache rates and 1.5x
  output for the whole request; batch and flex at half price.
- **The Codex route, primary.** This Mac has `codex-cli 0.155.0`;
  `codex login status` answers "Logged in using ChatGPT", so it runs on the
  subscription and not on an API key, and `~/.codex/config.toml` already sets
  `model = "gpt-6-astra"` at high effort. OpenAI's
  [Codex pricing page](https://learn.chatgpt.com/docs/pricing) includes Codex in
  every ChatGPT plan and estimates Astra at 5 to 45 local messages per five
  hours on Plus and Business, 25 to 225 on Pro 5x and 100 to 900 on Pro 20x,
  "not fixed message limits"; past the limit Plus and Pro users "can purchase
  additional credits", and "when you use Codex with an API key, API pricing
  applies". Which plan this seat is on is unrecorded.
  [Non-interactive mode](https://learn.chatgpt.com/docs/non-interactive-mode):
  `codex exec` is read-only by default, `--sandbox workspace-write` allows
  edits, `--json` streams JSON Lines events whose `turn.completed` carries
  `input_tokens`, `cached_input_tokens` and `output_tokens`, `--output-schema`
  constrains the final answer to a JSON Schema, `codex exec resume` continues a
  session, and an MCP server marked `required = true` that fails to start makes
  the run exit. The same page recommends an API key for CI and calls
  ChatGPT-managed auth in automation an advanced setup not meant for public
  repositories, so this lane runs on the owner's own signed-in machines only and
  no `auth.json` is ever copied into the repository or an image.
- **OpenRouter also lists it, primary, and the decision above refuses that
  route** (`GET https://openrouter.ai/api/v1/models`, 445 models, read
  2026-09-18): `openai/gpt-6-astra` and `openai/gpt-6-astra-pro` at 10 and 50
  USD per million, context 1 050 000, input modalities file, image and text,
  listed 2026-09-04 20:13Z; `:batch` variants at 5 and 25 USD; the floating
  alias is `~openai/gpt-astra-latest`. The same catalog on the same day, USD per
  million input and output, with input modalities:

  | Model                                                   | In    | Out   | Input modalities                |
  | ------------------------------------------------------- | ----- | ----- | ------------------------------- |
  | `openai/gpt-6-astra`                                    | 10.00 | 50.00 | text, image, file               |
  | `anthropic/claude-fable-5.1`                            | 10.00 | 50.00 | text, image, file               |
  | `anthropic/claude-opus-5`                               | 5.00  | 25.00 | text, image, file               |
  | `moonshotai/kimi-k3`                                    | 2.10  | 10.95 | text, image, video              |
  | `openai/gpt-5.6-sol`                                    | 2.00  | 10.00 | text, image, file               |
  | `google/gemini-3.8-flash`                               | 0.75  | 3.75  | text, image, video, audio, file |
  | `openai/gpt-5.6-luna`                                   | 0.20  | 1.20  | text, image, file               |
  | `deepseek/deepseek-v4.1-flash`                          | 0.15  | 0.60  | text, image                     |
  | `z-ai/glm-5.3-flash`                                    | 0.09  | 0.30  | text, image, video              |
  | `qwen/qwen3.5-flash-02-23`                              | 0.065 | 0.26  | text, image, video              |
  | `deepseek/deepseek-v4-flash-0731` (the harness binding) | 0.06  | 0.12  | text only                       |

  Two consequences. The repository's harness model cannot see a frame, so any
  visual critic in a harness needs a second cheap binding (GLM-5.3-flash or
  Qwen3.5-flash are the cheapest that take images and video). And Astra costs
  167x the harness model on input and 417x on output, 111x and 167x against
  GLM-5.3-flash.

- **What Astra does in Blender, as reported (secondary; OpenAI published no
  Blender benchmark, no repeated-attempt success rate and no controlled
  comparison).** It plans a scene, writes Blender Python, renders, inspects the
  frames and revises, and can also operate the application through computer use.
  Reported scores: OSWorld 2.0 72.6 per cent, BenchCAD 95.9 per cent
  ([Neural4D](https://blog.neural4d.com/neural4d/gpt-6-astra-3d-modeling/)).
  Reported strengths: constructed and hard-surface objects, architecture,
  product scenes, materials, three-point lighting, camera moves, GLB export.
  Reported weaknesses: organic forms, topology, UV seams, floating and
  intersecting objects, impossible thicknesses, overexposed metal, rigging and
  skin weights unproven, simulation untested, long animation passes that outlive
  an MCP tool window
  ([Kingy guide](https://kingy.ai/blog/blender-openai-astra-complete-guide/),
  [Neural4D MCP guide](https://blog.neural4d.com/user-guide/gpt-6-astra-blender-mcp/)).
  One documented Blender session used about 56 million tokens (secondary): at
  the API prices above that would be between about 56 USD if every input token
  were a cache read and 560 USD if none were, before any output token, against
  an OpenRouter balance of 28.25 USD on 2026-09-15. That arithmetic is one more
  reason for the decision above; on the subscription the same session costs
  allowance and hours, not dollars.
- **Astra's knowledge predates the pinned Blender.** Blender 5.2 LTS was
  released on 2026-07-14 and is supported until July 2028
  ([release notes](https://developer.blender.org/docs/release_notes/5.2/));
  Astra's cutoff is 2026-04-30. The 5.2 changes it cannot know include the
  removed `use_linear_modifiers`, the changed Geometry Nodes modifier property
  access and the new sequencer API below. This Mac runs **Blender 5.2.1 LTS**,
  build date 2026-08-25 (`Blender --version`).
- **Blender 5.2 LTS, the film-relevant changes, primary**
  ([sequencer](https://developer.blender.org/docs/release_notes/5.2/sequencer/),
  [pipeline and I/O](https://developer.blender.org/docs/release_notes/5.2/pipeline_io/)):
  a Compositor effect strip that runs a compositor node tree on the timeline
  with zero, one or two inputs; compositor node trees saved as strip-modifier
  assets with exposed inputs, GPU accelerated; HDR and wide-gamut scopes with a
  nits grid; text strip style presets (Subtitles, Main Title, Corner Title);
  scene strips gain a view layer selector; every audio and video stream of a
  file is imported; Python adds the strip `.connections` property and an
  optional `stream` argument on `strips.new_movie` and `strips.new_sound`, and
  removes `.use_linear_modifiers`; movie timecode files (`.blen_tc`) are gone.
  USD import converts colours to the blend file's working space and export tags
  colour spaces; Alembic imports animated camera data and visibility as
  F-curves; OpenEXR writes half float faster; video output carries stereoscopic
  and panoramic metadata; glTF gains meshopt, point clouds, iridescence and
  dispersion.
- **Blender 5.3 is in alpha until 2026-09-30 and expected on 2026-11-10**
  ([5.3 notes](https://developer.blender.org/docs/release_notes/5.3/)). Landed
  in the sequencer so far, primary: ripple delete, scene strips that follow
  their scene's frame range, thumbnails for scene, text, mask and clip strips
  ([5.3 sequencer](https://developer.blender.org/docs/release_notes/5.3/sequencer/)).
  The notes do **not** yet list media bins, three-point editing or
  OpenTimelineIO. OpenTimelineIO export and import exist as work-in-progress
  pull requests from a 2026 Summer of Code project
  ([#158562](https://projects.blender.org/blender/blender/pulls/158562),
  [#161207](https://projects.blender.org/blender/blender/pulls/161207)). Native
  Gaussian splats are reported for 5.3 (secondary:
  [radiancefields.com](https://radiancefields.com/blender-5.3-will-bring-native-3d-gaussian-splat-import-and-rendering)):
  PLY and SPZ v4 import, a splat type on the point cloud data-block, all three
  render engines through an emissive shader, an sRGB assumption that misbehaves
  in a linear pipeline, and only rudimentary relighting.
- **Blender Lab MCP is at 1.0.3, primary**
  ([Lab page](https://www.blender.org/lab/mcp-server/)): Blender 5.1 or newer;
  tools for documentation search over the Python API, scene inspection, Python
  execution, data analysis and data-block management; llama.cpp is the
  documented local client. The warning is unchanged: "The MCP server will
  execute LLM generated code in Blender without any guards in place to protect
  your data from removal or being sent to a remote location." The releases page
  answered 403; a search snippet dates 1.0.3 to 2026-09-11 with a fix to the
  screenshot capture tool and 1.0.2 to 2026-09-08 (secondary). The 2026-09-13
  review above assumed no screenshot tool; T.20.01 re-checks that. The community
  server is reported to carry CVE-2026-10688 and an unauthenticated local socket
  (secondary, a vendor blog; F.00.04 checks the CVE record).
- **Research, primary (arXiv abstracts).**
  [FilmAgent](https://arxiv.org/abs/2501.12909): director, screenwriter, actor
  and cinematographer roles that critique each other over idea, script and
  camera stages in a 3D space; human raters gave 3.98 of 5.
  [Cutscene Agent](https://arxiv.org/abs/2604.25318): a director agent over
  animation, cinematography and sound subagents, MCP into the engine, a visual
  feedback loop, and CutsceneBench for long-horizon orchestration.
  [CinemaTraj](https://arxiv.org/abs/2607.26910): a camera prompt decomposed
  into atomic moves (dolly, orbit, crane, pan, tilt, zoom, arc) over a 3D scene
  graph with collision-aware optimisation.
  [3DHarnessBench](https://arxiv.org/abs/2609.06535) (2026-09-06): four tiers of
  access, from a single view to full Blender function calls; every frontier
  model improves significantly with richer access, and the models are highly
  uneven. [BlenderGym](https://arxiv.org/abs/2504.01786): 245 scenes over five
  editing tasks; BlenderBench, [SceneActBench](https://arxiv.org/abs/2607.22393)
  and [3DCodeBench](https://arxiv.org/abs/2606.01057) follow it. None of them
  measures film making.
- **Industry practice.** Blender passes (depth, outline, pose) driving Wan VACE
  in ComfyUI is an established open workflow
  ([RunComfy write-up](https://www.runcomfy.com/comfyui-workflows/blender-to-comfyui-ai-renderer-2-0-workflow-cinematic-video-output));
  this repository already renders Wan 2.2 VACE, LTX and SeedVR2 (V.08, V.11) and
  plans Uni3C camera control (E.03.06). Agent-driven editing runs on
  OpenTimelineIO (0.18.1, Academy Software Foundation), and no MCP server
  targets Blender's sequencer
  ([open-source-cinema survey](https://github.com/ismael-joffroy-chandoutis/open-source-cinema/blob/master/Agent-Driven-Editing-2026.md)).
  NVIDIA's Audio2Face-3D is open: MIT code, weights under the NVIDIA Open Model
  License, plugins for Maya and Unreal and none for Blender
  ([repository](https://github.com/NVIDIA/Audio2Face-3D)). Blender Studio runs
  productions on Kitsu, a shot builder and the Flamenco render manager
  ([pipeline overview](https://studio.blender.org/tools/pipeline-overview/introduction)).

## Film track design decisions (defaults chosen 2026-09-18; each is one line to flip)

1. **The film is data and Blender executes it.** A production is a versioned
   manifest (sequences, scenes, shots, versions, department outputs). Every
   `.blend` is built from it by versioned operations (T.20.02), so an agent's
   work replays without the agent and an artist's hand edit is a recorded
   revision, never overwritten.
2. **The director stays provider-independent; Astra is an opt-in profile on the
   Codex subscription and nowhere else** (the 2026-09-18 decision above). This
   extends T.08.03 and the open-core decision. Every department runs on the
   cheap binding in harnesses. Any other frontier controller is billed through
   OpenRouter and runs only under a cap the owner set, and H.00.01 already
   records that frontier vendors need an owner decision.
3. **Roles are routed by measured success per unit of what they cost.** Planner,
   operator, still critic, dailies critic and writer are separate bindings. A
   billed model costs dollars; Astra costs a scarce allowance (as few as 5
   messages in five hours on the smallest plan), so it is spent on the planning
   and repair steps where it measures best and never on routine operation. Astra
   takes no video, so reviewing a clip goes to a video-input model. F.01.06
   measures; reputation does not route.
4. **Tested skills before free-form code.** The controller calls versioned
   Blender operations with schemas and post-condition checks. Free-form Python
   is the explicit advanced route, in the isolated runner. Three reasons: tokens
   (the 56 million token session), replay, and the knowledge cutoff, which is
   why the harness serves version-matched API documentation.
5. **Headless first, live MCP for steering, computer use last** (the T.19–T.21
   route table). Bakes, caches, renders and mixdowns are jobs that a tool call
   submits and polls; none runs inside one tool call.
6. **A deterministic gate precedes every critic.** The 180 degree line is
   geometry, exposure is a histogram of linear pixels, loudness is an EBU R128
   measurement, lip sync is an offset between aligned phonemes and keys. Critics
   advise; validators decide (T decision 7).
7. **The faithful render and the generative finish are two labelled lanes**
   (T.14.05). The 3D render is the truth for layout and continuity; a generated
   finish is measured against it and labelled as generated.
8. **Open interchange everywhere.** Fountain for the screenplay, OpenTimelineIO
   for the cut, multilayer OpenEXR with Cryptomatte for frames, OpenColorIO for
   colour, USD, Alembic and glTF for assets and caches, SRT and WebVTT for
   captions, EBU R128 for loudness.
9. **Blender 5.2 LTS is the production pin.** 5.3 features (native splats,
   native OpenTimelineIO if it lands) are gated on its release and a
   requalification; nothing here depends on an alpha.
10. **Anything sent to a hosted model is `sfw_only`** (hosted lane decision 2).
    An `adult_ok` production runs its critics on self-hosted models or without
    one; its frames, scripts and audio never reach a hosted controller.
11. **Locks are human acts.** Script, boards, layout, animation, picture and mix
    each lock by a person. Agents propose between locks, and every lock is a
    spend gate.

## What the film track reuses and what it adds

| Department                 | Already in this file                                                      | F adds                                                                                                              |
| -------------------------- | ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Story and planning         | Prompt assist (E.02)                                                      | Screenplay, breakdown, shot list, continuity state, style bible (F.04)                                              |
| Boards and animatic        | Nothing                                                                   | Panels from the blockout, Grease Pencil layer, timed animatic (F.05)                                                |
| Previs and layout          | Scene assembly, camera presets, shot checks (T.14.01, T.14.04)            | Sets to scale, blocking, shot-size framing, line and eyeline geometry (F.06)                                        |
| Cinematography             | Orbit, dolly, hold, framing solver (T.14.04)                              | Physical lens model, the full move vocabulary, focus, shake, coverage (F.07)                                        |
| Sets and characters        | Asset lanes, PBR, rigs, certificates (T.05–T.11)                          | Procedural sets, dressing, skies, splat sets, casting, wardrobe, crowds (F.08, F.09)                                |
| Performance                | Motion library, motion plans, retargeting, contact QA (T.12, T.13)        | Blocking and spline passes, props and contact, acting checks, faces and lip sync (F.10, F.11)                       |
| Lighting and effects       | Nothing beyond a render's default lights                                  | Measured light rigs, exposure, continuity, look development, cached simulation (F.12, F.13)                         |
| Rendering                  | Bounded stills, turntables and MP4 (T.14.05)                              | Passes, colour pipeline, render farm, estimates, render QA (F.14)                                                   |
| Compositing and finishing  | Wan VACE, LTX, SeedVR2, SAM 3.1 mattes (V.08, A.01)                       | Comp templates, relight in comp, control passes into the video lane with fidelity checks (F.15, F.16)               |
| Editorial, sound, delivery | Audio handoff in T.14.05; audio libraries under `libs/isis` are unaudited | OpenTimelineIO cut, sequencer bridge, dailies, spotting, mix, grade, masters, QC (F.17–F.19)                        |
| Agent layer                | Typed director tools, critics, transports (T.08, T.19–T.21)               | Controller admission and routing, film skills, tiers of access, token governor, a film benchmark (F.01, F.02, F.20) |

## Film cost model (every figure a sticker until F.20 measures it)

- **Controller tokens** are the new cost, and the two lanes count it
  differently. For a billed model, one 20-step shot session of 200 000 input
  tokens a step and 4 000 output tokens a step costs about 0.38 USD on
  GLM-5.3-flash at list price with no cache discount assumed (4 million in at
  0.09, 0.08 million out at 0.30), so a ten-shot film at five sessions a shot is
  about 19 USD; F.01.04 caps it. The same session through Astra's API would be
  about 11.60 USD at a 90 per cent cache-hit rate (0.4 million uncached at 10,
  3.6 million cached at 1, 0.08 million out at 50), about 580 USD a film, which
  is the route the decision above refuses.
- **Astra on the subscription costs allowance and wall time.** At the published
  estimates a 20-step session is most or all of a five-hour window on Plus or
  Business and a fraction of one on Pro 20x, so a film's Astra work is scheduled
  across windows and F.01.09 meters it in messages, tokens reported by
  `codex exec --json`, and hours. F.01.05 keeps the steps small, and F.01.06
  finds out where Astra earns its allowance.
- **Render** is frames times seconds per frame times the card rate. At the
  measured 0.00105 USD a second (V.11), a 60 second film at 24 frames a second
  is 1 440 frames; at 30 seconds a frame that is 43 200 GPU seconds, about 45
  USD. The seconds per frame are unmeasured; F.14.05 times them before any
  spend.
- **Simulation and CPU stages** run on the Linux server at no marginal cost but
  a real wall-clock and memory cost under the machine limits in `CLAUDE.md`.
- **Generative finishing** uses the measured V.11 clip costs.

## Suggested order for the film track

1. F.00 (audit and decisions), then F.03 (the production model) and F.02.01 to
   F.02.05 (skills, queries, jobs). None of it spends.
2. F.20.01 and F.20.02: the film benchmark and the cheap-binding baseline. They
   tell F.00.03 what a dearer controller would be asked to fix. F.01.08 and
   F.01.09 (the Codex lane and its meter) can be built beside them; they spend
   nothing until a run is started.
3. F.04 to F.07: a script becomes a shot list, boards, an animatic and a laid
   out, continuity-checked previs. This is the first thing worth showing.
4. F.17.01 to F.17.05 early: the cut exists from the animatic onward, and every
   later department delivers into it.
5. F.10 to F.15 by shot, then F.16, F.18 and F.19.
6. F.01.06 (the bake-off: Astra on the subscription, the billed candidates when
   the owner approves their cap), then F.20.05 (the pilot film) and F.20.06 (the
   capability matrix).

## F.00 Phase control, reuse audit and owner decisions

Dependencies: none; read-only work can start now.

- [ ] **F.00.01** Open `docs/agents/isis-film-studio-evidence.md` and bind the F
      sections to the C.00 tracker rules: every `[x]` cites files, test counts,
      measured numbers and any spend (controller tokens by model, GPU seconds,
      simulation hours). **Verify:** the evidence file exists with one heading
      per F section, and the first closed F item links to it.
- [ ] **F.00.02** Reuse audit, read-only, of the libraries the film track would
      lean on: `video-edit-studio`, `audio-generation`, `music-generation`,
      `voice-cloning`, `motion-camera-control`, `relight-studio`,
      `face-synthesis`, `3d-video-diffusion`, `3d-scene-assembly`,
      `scene-from-image-composer`, `ai-video`, `3dgs-relighting-pbr` and
      `3dgs-diffusion-editing`. Classify each public entry point as real
      computation, a catalogue with no data (the `humanoid-animation-library`
      finding), or a fabricated result, using both passes of the checkbox rule.
      **Verify:** a table in the evidence file with file and line per finding;
      anything that fabricates is fixed to fail loud or excluded from F
      dependencies before an F item builds on it, as T.00.03 did.
- [ ] **F.00.03** Record the owner's decisions, each with its date and words.
      Already made, 2026-09-18: Astra runs on the Codex subscription only (the
      block above). Still open: (a) a spend cap for the OpenRouter-billed
      candidates of the F.01.06 bake-off, or a refusal (Astra is not among
      them); (b) which ChatGPT plan the Codex seat is on and how much of each
      five-hour window the film lane may use, so it never starves the owner's
      own Codex work or Eve's agent; (c) the brief for the F.20.05 pilot film
      (length, style, characters, rating); (d) native shot tracking only, or a
      Kitsu sync as well (F.03.05); (e) the scene-linear working space
      (F.14.03); (f) an HDR master or not (F.19.04). **Verify:** a decisions
      block like the 2026-09-13 ones above; an item that depends on an unmade
      decision stays open and names it. _2026-09-18: (a) to (f) were **decided
      under the owner's delegation** and are written out in the decisions block
      of that date near the top of this file; the Astra decision named above
      them was the owner's own. What is left for an agent: copy the block into
      `docs/agents/isis-film-studio-evidence.md` under `## F.00` with the date
      and the delegation sentence, leave the ChatGPT plan name of (b) as an
      empty field, and make F.01.04, F.01.09, F.03.05, F.14.03, F.19.04 and
      F.20.05 each cite the decision they depend on. **Verify (unchanged):** an
      item that depends on a decision names it._
- [ ] **F.00.04** Re-read the facts block from primary sources. OpenAI's
      announcement, its terms, the Blender Lab releases page and the project
      source answered 403 to the fetcher; read them in a browser and store a
      sha256 of the extracted text as H.00.01 does. Replace or strike every
      figure marked secondary: the release date, OSWorld 2.0, BenchCAD, the 56
      million token session, the CVE identifier, the 5.3 splat details.
      **Verify:** no secondary figure remains unmarked; the CVE is checked
      against its public record; a struck figure stays visible as struck.

## F.01 Controller admission, routing and spend control

Dependencies: F.00.03 for anything that spends; extends T.08.03 and H.00.01. Two
lanes: models billed through OpenRouter (F.01.04 meters dollars) and OpenAI
models on the Codex subscription (F.01.08 runs them, F.01.09 meters allowance).
The owner's decision names Astra. Sending every other OpenAI model down the same
lane is this plan's default, because H.00.01 already excludes OpenAI from the
billed lane; it is one line to flip.

- [ ] **F.01.01** Controller terms register: one row per text or vision model a
      film role may call (Anthropic, Google, Moonshot, Z.ai, Qwen, DeepSeek, any
      local model's licence, and OpenAI on the Codex lane) with the terms URL,
      read date and hash, ownership of generated code and plans, training on
      inputs, zero data retention on the OpenRouter route, UK service, and what
      the role sends (scripts, scene JSON, rendered frames, audio, transcripts).
      The OpenAI row covers the ChatGPT plan and Codex terms that govern
      unattended `codex exec` on a subscription seat, and records the lane as
      operator-side only. **Verify:** a spec fails when a routed model has no
      row; a model new in the catalog is unreviewed and refused; the Codex lane
      does not run unattended until its terms row is read and hashed.
- [ ] **F.01.02** Discover capabilities from the live source and never from
      constants. For the OpenRouter lane, the catalog: input modalities,
      context, maximum output, input, cached and output prices, the long-prompt
      surcharge threshold, the batch variant. For the Codex lane, the installed
      CLI: its version, the login mode, the configured model and the models it
      offers. **Verify:** the router refuses to send a clip to a model whose row
      lacks video and names the reason; a catalog price change moves the
      estimate with no code edit; a Codex seat that is not "Logged in using
      ChatGPT" makes the Codex lane unavailable, with the reason.
- [ ] **F.01.03** Role routing table: planner, operator, still critic, dailies
      critic and writer each bind to a model and a lane per production profile.
      The default profile is the cheap binding plus one cheap vision model; a
      frontier profile is opt-in per production. Astra and every other OpenAI
      model bind to the Codex lane only. **Verify:** with hosted providers
      disabled a production still plans and runs, or reports exactly which role
      is unavailable; nothing upgrades itself to a paid model (the T.08.03
      rule); a spec proves that no profile, environment variable or catalog row
      can route an OpenAI model id to the OpenRouter or OpenAI API transports,
      and that `openai/gpt-6-astra*` from the OpenRouter catalog is refused by
      name.
- [ ] **F.01.04** Token ledger and governor for OpenRouter-billed controller
      spend: budgets per production, sequence, shot and department; a
      reservation before each call; the actual from the provider's reported
      cost; fail closed when no cost comes back. Stop conditions are budget, an
      iteration cap and no measured improvement over a set number of rounds.
      **Verify:** a loop about to pass its cap stops before the call and saves
      its partial work as a revision; the ledger of a proof run equals the
      OpenRouter activity log to the cent.
- [ ] **F.01.05** Cache-aware context assembly: a stable prefix (skill schemas,
      the style bible, the production summary) and a volatile suffix (the scene
      delta, the latest frames); scene deltas instead of scene dumps; an image
      budget per call by count and resolution. **Verify:** the cache-hit rate of
      a 20-step session is recorded against a threshold; tokens per step stay
      flat when the scene grows tenfold in objects.
- [ ] **F.01.06** The controller bake-off: the F.20.01 task set run by each
      candidate profile under matched step, token and time caps. On the Codex
      lane, inside F.00.03(b)'s allowance: Astra at two reasoning efforts and
      GPT-5.6 Luna. On the OpenRouter lane, spending only under F.00.03(a):
      Claude Fable 5.1 and Opus 5, Gemini 3.8 Flash, Kimi K3, GLM-5.3-flash,
      Qwen3.5-flash, DeepSeek V4.1 flash. Record success, quality scores,
      tokens, wall time, and USD or allowance used per department. **Verify:**
      repeated runs with sample sizes and uncertainty; failed runs kept; the
      result, not a vendor demo, fills F.01.03's table.
- [ ] **F.01.07** A batch lane for work nobody waits on (breakdowns, shot list
      drafts, overnight dailies notes) at the `:batch` half price for
      OpenRouter-billed models, and as queued `codex exec` runs in quiet windows
      for the Codex lane. **Verify:** a batch result lands as a proposal on the
      version it was asked about; a late result never overwrites a newer
      revision.
- [ ] **F.01.08** The Codex lane: `tools/isis-codex-director.mjs`, modelled on
      `tools/eve-codex-agent.mjs`. It runs `codex exec --json` with a pinned
      model and effort, `--output-schema` for the typed result, and one
      `required = true` MCP server that exposes the F.02.01 film skills against
      a job directory; `workspace-write` at most, `danger-full-access` refused;
      per-run secrets in a 0600 profile and never in argv; `--list`, `--smoke`
      and `--dry-run` modes that start no model. Before every run it checks that
      `codex login status` says ChatGPT, and it removes `OPENAI_API_KEY`,
      `CODEX_API_KEY` and every other provider key from the child environment,
      because a key there moves Codex to API billing. **Verify:** unit specs for
      the argv and the scrubbed environment; a run with an API key planted in
      the parent environment still reaches the child without it; an API-key
      login refuses to start; `--smoke` drives the MCP server exactly as Codex
      would; the JSON Lines stream parses into typed events, and a missing
      `turn.completed` fails the run.
- [ ] **F.01.09** Allowance governor for the Codex lane: a budget per production
      and per five-hour window in runs, turns, reported tokens and wall time; a
      reservation before each run; a rate-limit or usage-limit answer recorded
      with its reset time and treated as a stop. It never retries on a billed
      route and never buys credits. **Verify:** a planted limit response stops
      the queue, saves partial work as a revision and schedules nothing before
      the reset; the window budget of F.00.03(b) holds across concurrent
      productions; the meter's token totals equal the sum of the
      `turn.completed` events of a proof run.

## F.02 Film agent harness: skills, queries, tiers and jobs

Dependencies: T.20.02, T.20.03 and T.08.02; extends T.20 and T.21.

- [ ] **F.02.01** Film skills library: versioned Blender operation modules on
      top of T.20.02 for cameras and lenses, light rigs, timeline markers and
      camera binding, view layers and passes, compositor node groups, sequencer
      strips, shape-key keying, simulation bakes and render jobs. Each skill has
      a JSON schema, preconditions and a post-condition it checks itself.
      **Verify:** every skill runs headless on 5.2.1 against fixture files with
      selection, mode and workspace scrambled; schema tokens are measured and
      listed.
- [ ] **F.02.02** Version-matched API knowledge. Serve the pinned Blender's
      Python API reference and the release-note deltas to the controller, by Lab
      MCP's documentation search where a live session exists and by a local
      index otherwise. A static pre-flight rejects calls to APIs the pinned
      build removed. **Verify:** a task needing a 5.2-only API (a compositor
      strip modifier, `strips.new_movie` with `stream`) passes with the index
      and its failure without it is recorded; `use_linear_modifiers` is refused
      before execution.
- [ ] **F.02.03** Four tiers of access after 3DHarnessBench (single view, multi
      view, active viewpoint, full scene queries), selectable per task, with the
      tier recorded per run. **Verify:** an ablation on the F.20.01 set gives
      the measured gain and token cost of each tier; the default tier per
      department comes from it.
- [ ] **F.02.04** Film scene queries as compact JSON: cameras with lens, sensor
      and focus; each subject's screen-space box and occluded fraction per
      frame; lights with power, colour and linking; character poses by named
      joints; markers; strips. Never a mesh dump. **Verify:** a cube at a known
      distance and focal length returns the hand-computed screen box; response
      size is bounded and listed.
- [ ] **F.02.05** Long operations are jobs. Animation bakes, simulation caches,
      renders and mixdowns run in the T.20.03 runner with progress, cancel and
      resume; a tool call submits and polls. **Verify:** a bake longer than the
      tool timeout completes; a lost response does not start it twice (the
      T.19.06 idempotency pattern).
- [ ] **F.02.06** Free-form script lane, contained: generated Python runs with
      no network, a scoped filesystem and time and memory bounds, after a static
      allow-list pass (no process launch, sockets, add-on installation, URL
      opening or writes outside the job directory). **Verify:** hostile scripts
      planted in scene metadata, text blocks and asset names are refused or
      contained; T.21.03's cases run on film fixtures.
- [ ] **F.02.07** Computer use, measured and narrow. Astra's headline is
      operating the application itself, so measure it: the same five tasks by
      skill route and by computer-use route, recording success, time and tokens.
      The computer-use route is the Codex app's own, on the subscription; the
      API's computer-use tool is a metered route and refused. Keep it only for
      operations with no API, each with the gap named. **Verify:** the
      comparison is in the evidence file; no batch job replays clicks; a
      repeated UI-only step becomes a skill or a recorded gap.
- [ ] **F.02.08** Skill promotion: a free-form script that passed its gates on
      two different shots is proposed as a skill with a spec and a fixture, and
      a person reviews it before it joins the library. **Verify:** promotion
      without a spec is refused; the library version bumps; an old production
      replays on the version it recorded.

## F.03 Production model: film, sequences, shots, versions and notes

Dependencies: T.04 manifests, T.14.01, T.14.03 and T.14.04.

- [ ] **F.03.01** Production manifest: film, sequences, scenes, shots and
      versions, with frame rate, resolution, aspect, colour pipeline, naming and
      handles, and a status per shot per department (boards, layout, animation,
      lighting, effects, render, comp, edit, sound, grade). **Verify:** schema
      validation; a shot rendered from a layout older than the current one is
      reported stale through T.14.03's dependency tracking.
- [ ] **F.03.02** Locks and approvals. Script, boards, layout, animation,
      picture and mix lock by a person; agents propose between locks; an
      upstream change lists every downstream shot it invalidates. **Verify:** an
      agent cannot write a locked department's output; an unlock records who,
      when and why; the invalidation list equals the dependency graph's answer
      on a fixture.
- [ ] **F.03.03** File layout and linking: one file per asset, per set and per
      shot; shots link with library overrides and relative paths; a shot builder
      creates the shot file from the manifest. **Verify:** a rebuilt shot file
      has the same objects, transforms and overrides; moving the production root
      keeps every link; a missing library fails loud.
- [ ] **F.03.04** Notes and review: frame-accurate notes on a shot version
      (text, a region, a drawn-over frame) from a person or a critic role, with
      a status; open notes become agent tasks. **Verify:** a note on frame N of
      version K stays on K when the next version arrives; a critic's note is
      labelled as a model's.
- [ ] **F.03.05** Optional Kitsu sync, under F.00.03(d): map productions, shots,
      tasks and statuses through its API. **Verify:** a round trip on a local
      Kitsu container; the core path runs with no Kitsu present. _2026-09-18:
      not planned — F.00.03(d) was decided as native shot tracking only. The box
      stays open so the choice is reversible; nothing here is for an agent to
      build._ `blocked:governance`
- [ ] **F.03.06** Lineage on everything delivered: shot version, scene revision,
      skill versions, controller model and prompt hash, and the faithful or
      generated label, through the existing provenance path. **Verify:** a
      delivered clip resolves back to its manifest versions; a generated finish
      is labelled generated.

## F.04 Story development: screenplay, breakdown and shot list

Dependencies: F.03.01; F.01.03 for the writer role.

- [ ] **F.04.01** Screenplay in Fountain: parse and serialise scene headings,
      action, characters, dialogue, parentheticals and transitions, so an agent
      revises the same plain text a person edits. **Verify:** the Fountain
      specification's own samples parse; the round trip is lossless; the running
      time estimate states its formula (dialogue word rate plus action lines)
      and is labelled an estimate.
- [ ] **F.04.02** Breakdown: characters, locations, props, wardrobe, vehicles,
      effects and time of day per scene, proposed by the controller and checked
      by rule. Every element cites the script lines it comes from. **Verify:**
      an element with no citation is rejected; deleting a cited line flags the
      elements that relied on it.
- [ ] **F.04.03** Breakdown to the T-track: each element resolves to a library
      asset, a generation request on the right lane (T decision 1) or an open
      need, carrying rights, rating and a cost estimate. **Verify:** no shot
      enters layout with an unresolved cast member, set or hero prop.
- [ ] **F.04.04** Shot list as typed data: shot size, angle, movement, lens
      intent, subject, duration estimate, the dialogue lines covered and the
      purpose, from named coverage patterns (master and singles, over the
      shoulder pairs, a designed single take). **Verify:** every dialogue line
      is covered; the summed estimate is within a recorded tolerance of the
      scene's.
- [ ] **F.04.05** Story state: who knows what, who holds what, wardrobe and time
      of day per scene, tracked as structured state. **Verify:** planted
      contradictions in a fixture script (a prop in two places, day to night
      with no transition, a costume change mid-scene) are caught with the scene
      numbers.
- [ ] **F.04.06** Style bible: reference frames, palette, lens language,
      lighting motifs, aspect ratio and grain, made with the existing image
      lanes and stored as the production's cached prefix. **Verify:** each
      reference has lineage and a licence; the bible's hash is in every
      downstream prompt's lineage.

## F.05 Storyboards and animatic

Dependencies: F.04.04; F.06.01 for the blockout route.

- [ ] **F.05.01** Board panels by two labelled routes: a Workbench or EEVEE
      still from the shot camera over the rough blockout, always faithful to the
      layout; or a generated still conditioned on that blockout's depth and line
      pass. Each panel belongs to a shot and a beat. **Verify:** panel count and
      order equal the shot list; generated panels are labelled; the subject's
      measured screen height falls in the band for the declared shot size.
- [ ] **F.05.02** Grease Pencil board layer: panels as Grease Pencil frames in a
      storyboard scene for an artist to draw over or replace, with arrows for
      camera and character movement taken from the planned motion. **Verify:** a
      hand-edited panel is never overwritten by a regeneration; arrow directions
      equal the planned vectors.
- [ ] **F.05.03** Animatic in the sequencer: panels as image strips timed from
      the shot list, scratch dialogue from the speech stack F.00.02 admits, temp
      music, slates with the 5.2 text presets; MP4 and OpenTimelineIO out.
      **Verify:** strip durations sum to the plan; measured audio offsets;
      ffprobe confirms frame count and rate (the T.14.05 pattern).
- [ ] **F.05.04** Timing review: a video-input critic watches the animatic and
      proposes retimes; an accepted retime flows back to shot durations.
      **Verify:** accepted retimes move downstream frame ranges and flag the
      locks they touch; a rejected one leaves nothing behind.
- [ ] **F.05.05** Boards to layout: an approved panel's camera and subject
      placement become the first layout of F.06. **Verify:** the layout's first
      camera matches the panel's within a recorded tolerance.

## F.06 Previs and layout

Dependencies: F.04.03, F.04.04, T.14.01 and T.14.04.

- [ ] **F.06.01** Set blockout from the breakdown: proxy geometry at real scale
      in metres with a 1.7 m figure for reference, floor plan, entrances and key
      props, built by skills. **Verify:** dimensions match the brief; a
      character proxy passes through doors and sits at furniture with measured
      clearance.
- [ ] **F.06.02** Character blocking: marks, paths and facing per beat on the
      floor plan, timed from dialogue durations, walked by proxies within gait
      speed bounds. **Verify:** no path crosses a solid; speeds stay in bounds;
      each character reaches its mark on its cue frame.
- [ ] **F.06.03** Camera layout per shot: extend T.14.04's framing solver from a
      bounding sphere to shot-size bands on a character (head, shoulders, waist,
      full), choose the lens from the style bible's set, set camera height, and
      bind cameras to timeline markers for multi-camera scenes. **Verify:**
      measured subject height in the band; measured headroom and lead room; the
      T.14.04 shot checks pass.
- [ ] **F.06.04** Continuity geometry: the 180 degree line as a plane through
      the subjects, each cut checked for a line cross, the 30 degree rule
      between setups on one subject, eyeline match from gaze vectors, and screen
      direction of movement. **Verify:** planted violations are caught with
      their angles; an annotated deliberate cross is allowed and recorded.
- [ ] **F.06.05** Previs playblasts per shot with burn-ins (shot, version,
      frame, lens, timecode), delivered into the cut (F.17) automatically.
      **Verify:** burn-in values equal the manifest; frame count equals the shot
      range plus handles.
- [ ] **F.06.06** What the camera sees sets the asset budget: screen coverage
      per asset from rendered ID passes decides its detail and texture tier for
      T.09 and T.10. **Verify:** an asset never larger than a set pixel size is
      requested at the low tier, from a measurement and not a guess.

## F.07 Cinematography: camera, lens and coverage

Dependencies: F.06.03; extends T.14.04.

- [ ] **F.07.01** Physical camera: sensor size, focal length, aperture, focus
      distance and shutter angle drive depth of field and motion blur; the lens
      set is production data; anamorphic is an option. **Verify:** the circle of
      confusion measured from a fixture render matches the thin-lens formula
      within tolerance; blur length follows the shutter angle.
- [ ] **F.07.02** The move vocabulary: dolly, truck, pedestal and crane, pan,
      tilt, roll, zoom, arc and orbit, push in, pull out and follow, composed
      with easing and optimised against collisions over the scene (CinemaTraj's
      decomposition), beyond T.14.04's orbit, dolly and hold. **Verify:** each
      move's keys match hand arithmetic; composed moves keep clearance from
      solids; speed and acceleration are bounded.
- [ ] **F.07.03** Focus: follow focus on a subject and racks between two on a
      cue, keyed from measured distances. **Verify:** the circle of confusion on
      the intended subject, computed from the depth pass, is under threshold at
      the cue frames.
- [ ] **F.07.04** Handheld and rigs: seeded procedural shake with amplitude and
      frequency per rig type, under a constraint that keeps the subject inside a
      framing box. **Verify:** identical for a seed; the subject never leaves
      the box; the frequency content is measured.
- [ ] **F.07.05** Composition as numbers: thirds or centre placement, headroom,
      lead room, horizon level and subject separation by luminance and depth,
      computed from ID and depth passes for the critic to use. **Verify:**
      fixtures with known placement return the expected values.
- [ ] **F.07.06** Coverage generation: for a dialogue scene, a full set of
      setups (master, over the shoulder pair, singles, inserts) on the right
      side of the line for the editor to cut from. **Verify:** every setup
      passes F.06.04; every dialogue line has at least two usable angles.

## F.08 Sets, environments and set dressing

Dependencies: F.06.01, T.06, T.07 and T.14.01.

- [ ] **F.08.01** Procedural sets with Geometry Nodes skills: architecture,
      terrain, vegetation scatter and streets, with parameters and seeds in the
      manifest. **Verify:** regeneration from parameters gives the same
      evaluated geometry hash; instancing keeps memory inside a recorded budget.
- [ ] **F.08.02** Set dressing from the asset library under T.14.01's layout
      relations (support, clearance, no interpenetration), with density led by
      what the camera sees (F.06.06). **Verify:** a support check finds no
      floating object and no intersection over tolerance, the two failures the
      public Astra reports name.
- [ ] **F.08.03** Skies and worlds through the world node tree (a world's colour
      field never reaches Cycles, the T.10 finding), with the sun placed from
      date, time and place, and admitted HDRI licences. **Verify:** three
      declared environments render measurably differently; the sun's elevation
      matches the ephemeris formula for a fixture.
- [ ] **F.08.04** Gaussian splat sets, gated on Blender 5.3's release: captured
      or generated environments as backgrounds, kept distinct from meshes (T
      decision), with proxy geometry for shadows and contact. The reported sRGB
      assumption must be measured in the linear pipeline of F.14.03. **Verify:**
      blocked with the date until 5.3 ships and qualifies; then parallax agrees
      between a splat background and a mesh foreground over a camera move.
- [ ] **F.08.05** A concept frame to a set: the reconstruction lane (T.07) or
      `scene-from-image-composer`, if F.00.02 admits it, gives a blockout and a
      matched camera. **Verify:** the solved camera's reprojection error against
      the image's vanishing lines is under tolerance; inferred geometry is
      labelled inferred.
- [ ] **F.08.06** Matte paintings and set extensions: generated plates projected
      from a locked camera onto cards or geometry, with the parallax-safe range
      computed. **Verify:** the projection holds within a pixel tolerance over
      the shot's move, or the shot is flagged.

## F.09 Characters, wardrobe and casting from the asset library

Dependencies: T.11 and T.13 certificates; F.04.03.

- [ ] **F.09.01** Casting: a character is a certified rigged asset, its
      capability manifest (T.11.06), a voice and wardrobe variants. A shot
      cannot cast a character that lacks what the shot needs, such as facial
      shape keys for a dialogue close-up. **Verify:** the refusal names the
      missing capability.
- [ ] **F.09.02** Character sheets from the pinned asset revision: turnaround,
      expressions and a scale chart (the T.08.04 views), as the reference for
      both the 3D lane and the generative finish. **Verify:** the sheet's
      lineage is the asset revision; a new revision marks the sheet stale.
- [ ] **F.09.03** Wardrobe variants per scene within T.11's clothing limits,
      with a slide check, because a garment that slides off the hip passes every
      deformation test. **Verify:** garment displacement relative to the body at
      its anchor regions stays bounded over the shot's motion.
- [ ] **F.09.04** Hair and fur as curves with guides; static grooms by default.
      Hair dynamics is on Blender's 2026 roadmap and has not landed, so none is
      claimed. **Verify:** a groom renders inside its time budget; a request for
      dynamics returns the recorded limitation.
- [ ] **F.09.05** Background characters: instanced low-tier characters with
      offset loops from the motion library through Geometry Nodes. **Verify:**
      no two neighbours in phase; memory bounded; sampled instances pass
      T.13.03's foot-slide thresholds.

## F.10 Body performance: blocking, acting and interaction

Dependencies: T.12.03 to T.12.06, T.13, F.06.02.

- [ ] **F.10.01** Performance plan per shot: script action lines become
      T.12.05's timed motion plan, extended with marks, props, gaze targets and
      dialogue cue frames. **Verify:** the plan covers the shot range and each
      action cites its script line.
- [ ] **F.10.02** Two typed passes: stepped key poses at the story beats, cheap
      to review, then the spline pass. The agent sets poses through named-joint
      skills under signed joint limits (an unsigned angle cannot see
      hyperextension). **Verify:** limits hold; contacts hold (T.13.03,
      T.13.04); jerk is bounded after the spline pass.
- [ ] **F.10.03** Motion sources with lineage: library clips, text-to-motion
      only once T.12.01 or T.12.02 is admitted, user BVH and FBX (T.12.04), and
      video-to-motion as an admission candidate whose body-model licences are
      the known obstacle. **Verify:** every clip in a shot carries its licence;
      an unadmitted source is refused.
- [ ] **F.10.04** Interaction: hand to prop attachment on cue frames, sitting
      and leaning contacts, two-character contact through IK targets, and
      look-at split between head and eyes. **Verify:** contact error under
      tolerance through the hold; penetration measured relative to rest.
- [ ] **F.10.05** Acting checks before any critic: silhouette change, hold
      lengths, and twinning found by left and right joint-angle correlation;
      then a video-input critic's notes on whether the beat reads. **Verify:**
      planted twinning and a missing hold are flagged with no model in the loop.
- [ ] **F.10.06** Adjustment layers over library motion with NLA strips (layered
      animation is roadmap, NLA ships today). **Verify:** muting the adjustment
      restores the certified clip exactly.

## F.11 Faces, dialogue and lip sync

Dependencies: F.09.01, F.04.01, F.00.02 for the speech stack.

- [ ] **F.11.01** Dialogue audio: takes per script line from the admitted voice
      lane, with a consent id for any cloned voice through the existing consent
      service, and each line's duration feeding shot timing. **Verify:** every
      take maps to a script line id; a cloned voice with no consent id is
      refused; lines are loudness-normalised.
- [ ] **F.11.02** Phoneme alignment: forced alignment of each take to its script
      text on the Linux server's CPU speech stack, giving phoneme and viseme
      times. **Verify:** against a hand-labelled fixture, the median boundary
      error is under a recorded number of milliseconds.
- [ ] **F.11.03** Viseme keying: map visemes to the character's shape keys
      through its capability manifest (the ARKit 52 set or a declared one), with
      coarticulation smoothing and jaw and lip limits. Rhubarb is the CPU
      baseline; Audio2Face-3D is an admission candidate under T.01 (MIT code,
      NVIDIA Open Model License weights, no Blender plugin, so its weights
      arrive as keys through a skill). **Verify:** lip closure keys for p, b and
      m sit within a recorded tolerance of their audio onsets; a viseme with no
      matching shape key is an error and never dropped.
- [ ] **F.11.04** Facial performance: brow, lid and cheek curves from
      parentheticals and the performance plan, blinks on gaze shifts and at a
      human rate, eye darts, and gaze targets from F.10.04. **Verify:** blink
      statistics in a human range; the eyes converge on the target by vergence
      geometry; no weight outside 0 to 1 and no opposed pair high together.
- [ ] **F.11.05** Close-up review sheets: mouth-region contact sheets with
      phoneme labels at the cue frames (the T.13.05 pattern). **Verify:** sheet
      frames equal the cue frames and carry their labels.

## F.12 Lighting and look development

Dependencies: F.06.03, T.10; F.14.03 for colour.

- [ ] **F.12.01** Light rigs as skills: three-point, soft key, motivated
      practicals, window and sky, moonlight and silhouette, in physical units
      with colour temperature by the blackbody formula, and light linking for
      rim and eye lights. **Verify:** the key to fill ratio measured on a grey
      sphere matches the request within tolerance; colour temperature matches a
      reference table.
- [ ] **F.12.02** Exposure by measurement: a grey card and a skin patch proxy
      per shot, zones computed from linear EXR pixels, clipping bounded
      (overexposed metal is a reported Astra failure). **Verify:** the grey card
      within a third of a stop of target; clipped fraction under threshold
      outside declared speculars.
- [ ] **F.12.03** Lighting continuity: a master rig per set with per-shot
      overrides; key direction and ratio compared across a scene's shots; time
      of day agrees with F.04.05. **Verify:** a key that flips sides between
      matching singles is caught.
- [ ] **F.12.04** Look development under a neutral rig with grey and chrome
      balls and a colour chart, extending T.10's material gates to skin, glass
      and emissive practicals in shot context. **Verify:** chart patches within
      a colour difference tolerance; albedo inside T.10's plausible range.
- [ ] **F.12.05** Mood from the style bible: a lighting brief per sequence
      (palette, contrast, key direction, motivated sources) becomes rig
      parameters, and the critic compares render and reference by palette
      distance and contrast ratio before it says anything in words. **Verify:**
      the numbers move toward the reference over iterations; the loop stops on a
      plateau (F.01.04).
- [ ] **F.12.06** Atmosphere: fog and light shafts with their render cost
      measured. **Verify:** the cost delta sits inside the shot's render budget
      or the effect moves to comp (F.15.01).

## F.13 Simulation and effects

Dependencies: F.10 for characters in motion; F.02.05 for jobs.

- [ ] **F.13.01** Simulation as cached, versioned stages: cloth, rigid and soft
      bodies, smoke, fire and liquid, and Geometry Nodes simulation zones, each
      baked to disk with seed, substeps, scale and range recorded; nothing
      simulates at render time. **Verify:** a re-bake on the same build matches
      within tolerance or the variation is recorded; a render with a missing or
      stale cache fails loud.
- [ ] **F.13.02** Cloth on characters: collision bodies from the character,
      pinned anchor groups, pre-roll from the rest pose, quality presets.
      **Verify:** penetration relative to rest under threshold; velocities
      bounded, so no explosion; the garment stays on (F.09.03).
- [ ] **F.13.03** Destruction and rigid bodies: fracture, constraints, margins
      and sleeping, with gravity at the scene's real scale. **Verify:** energy
      does not grow; at rest nothing floats and nothing sinks.
- [ ] **F.13.04** Smoke, fire and liquid: domain resolution from screen
      coverage, bake time and disk estimated before the run, OpenVDB caches.
      **Verify:** estimate against actual recorded; the domain contains the
      effect for the whole shot unless a wall is intended.
- [ ] **F.13.05** Procedural effects with Geometry Nodes: rain, snow, dust,
      sparks, debris and growth, all seeded. **Verify:** deterministic for a
      seed; nothing simulated far outside the camera frustum and its margin.
- [ ] **F.13.06** Simulation governor: a bake reserves CPU hours and disk before
      it starts, a runaway is cancelled, and caches are lineage-tracked
      artifacts under a disk cap, run within the machine limits in `CLAUDE.md`.
      **Verify:** a cancel leaves a resumable partial cache; the cap holds.

## F.14 Rendering: passes, colour pipeline and the render farm

Dependencies: T.14.05, T.02, T.03, L.03; F.00.03(e).

- [ ] **F.14.01** Render settings as production data: the engine per output
      (Workbench playblast, EEVEE previs, Cycles final), samples and adaptive
      threshold, denoiser policy, motion blur, filter and seed policy (fixed for
      determinism tests, animated for finals). **Verify:** a file whose settings
      drifted from the manifest is flagged before it renders.
- [ ] **F.14.02** Passes: multilayer OpenEXR, half float where it suffices and
      full float for depth and position, with beauty, the light-path components,
      depth, normal, vector, position, Cryptomatte for object, material and
      asset, light groups per rig role, and a shadow catcher. **Verify:** parsed
      EXR headers show every declared layer with the right type; light groups
      sum to beauty within tolerance; Cryptomatte manifests decode to the
      scene's object names.
- [ ] **F.14.03** Colour pipeline: a pinned OpenColorIO configuration, a
      scene-linear working space chosen under F.00.03(e), a view transform for
      review, display-referred files made only at delivery, and every texture
      tagged. **Verify:** a rendered colour chart lands within tolerance through
      the whole pipeline; an untagged texture is flagged; a normal or roughness
      map tagged sRGB is an error.
- [ ] **F.14.04** Render farm: a RunPod GPU Blender worker kind on pinned 5.2
      LTS inside the existing job, ledger and cap machinery, with frames as
      idempotent units, chunking, resume, retry of failed frames only, and
      inputs synced through the library path. Flamenco on the Linux server is
      the measured alternative for CPU work. **Verify:** a 48 frame proof across
      at least two worker invocations with one injected failure yields a
      complete, hash-checked frame set; the ledger equals RunPod's bill; no
      frame renders twice unless its inputs changed.
- [ ] **F.14.05** Estimate before spend: time the first, middle, last and
      heaviest frames at final settings, extrapolate with uncertainty, and
      approve against the shot's budget, labelled sticker until measured (the
      V.04 pattern). **Verify:** on the proof, the estimate is within a recorded
      factor of the actual.
- [ ] **F.14.06** Render QA by rule: missing and duplicate frames, NaN and
      infinite pixels, fireflies, black frames, denoiser flicker in static
      regions, and the camera and revision stamped in the EXR header against the
      manifest. **Verify:** each planted defect is caught in a fixture sequence.
- [ ] **F.14.07** Quality ladder: playblast, EEVEE, low-sample Cycles, final.
      The agent iterates at the cheapest tier that can show the defect under
      discussion. **Verify:** the tier of every iteration is recorded; a final
      render happens only after a lock or an explicit approval.

## F.15 Compositing

Dependencies: F.14.02, F.14.03.

- [ ] **F.15.01** Comp templates as node-group assets: beauty rebuild from
      passes, light-group grade, Cryptomatte mattes, depth fog and defocus,
      vector blur, glare, lens distortion and chromatic aberration, grain and
      vignette, with per-shot parameters in the manifest. **Verify:** the
      rebuilt beauty equals the rendered beauty within tolerance; each template
      has a fixture EXR test.
- [ ] **F.15.02** Relight in comp before a re-render: a lighting note inside the
      span of the light groups is met without rendering again, with the limit
      stated (no new shadows). **Verify:** the harness takes the comp route when
      the note allows and records when it cannot.
- [ ] **F.15.03** Plates: mattes from the existing SAM 3.1 and BiRefNet lane, a
      camera solve from Blender's tracker run headless, and shadow catcher
      passes for integration. **Verify:** the solve's reprojection error under
      threshold; matte edges checked on the hair fixture with the alpha polarity
      lesson from V.08.
- [ ] **F.15.04** Sequencer-level comp with 5.2's compositor strips and strip
      modifier assets for film-wide treatments (grain, halation, letterbox).
      **Verify:** one node group applied as a strip modifier and in the scene
      compositor agrees within tolerance; the preview and render toggles are
      honoured.
- [ ] **F.15.05** Comp QA: matte holes, edge halos, negative values,
      premultiplication errors and out-of-gamut pixels before the display
      transform. **Verify:** each planted defect is caught.

## F.16 Hybrid generative finishing: Blender control passes into the video lane

Dependencies: F.14.02, V.06, V.08, E.03.06; spend under the existing V rules.

- [ ] **F.16.01** Control passes from a locked shot: depth, normal, outline, an
      OpenPose-style skeleton projected from the rig's own joints (exact, not
      estimated), ID colours and optical flow from the vector pass, on the video
      model's size and frame grid (`snapMotionFrames`, `checkMotionCaps`).
      **Verify:** projected joints land on the rendered character within a pixel
      tolerance; frame counts pass `checkMotionCaps`.
- [ ] **F.16.02** Workflows in the `motion` catalog: a VACE restyle driven by
      the control video and reference frames, an LTX control route where a
      control adapter exists for the admitted LTX version (V.12.02's are
      2.3-only), and Uni3C camera control from the Blender camera path.
      **Verify:** the three offline proofs per graph; one live clip per workflow
      inside an approved spend.
- [ ] **F.16.03** Reference frames: first, last and key frames made by the image
      lanes from the 3D render and the style bible, with identity from F.09.02's
      sheets. **Verify:** every reference derives from the same shot version.
- [ ] **F.16.04** Fidelity against the 3D truth: depth re-estimated from the
      output against rendered depth, poses re-detected against the projected
      skeleton, the camera path re-solved against Blender's, identity against
      the character sheet, and a temporal flicker measure. **Verify:**
      thresholds per workflow; a clip that fails layout fidelity is rejected and
      not shipped as a style.
- [ ] **F.16.05** Long shots: overlapping windows with shared references, which
      V.08 recorded as not done for `continue_motion`. **Verify:** a
      flow-compensated difference at each window join stays under threshold.
- [ ] **F.16.06** Label, policy and mixing: a generated finish is always
      labelled (T.14.05); `adult_ok` never goes to a hosted step; a shot may mix
      a generated background plate with a rendered character in F.15.
      **Verify:** a refused lane names its reason (hosted lane decision 3).

## F.17 Editorial: Blender's sequencer, OpenTimelineIO and dailies

Dependencies: F.03.01; F.05.03 starts the cut.

- [ ] **F.17.01** The cut is an OpenTimelineIO timeline of tracks, clips with
      source ranges, gaps, transitions and markers that reference shot versions,
      through the pinned Python API. **Verify:** a lossless round trip for the
      schema subset in use; an invalid range is refused.
- [ ] **F.17.02** A bridge between OpenTimelineIO and the 5.2 sequencer (movie,
      sound, image, scene and text strips, transitions), ours until Blender's
      own import and export ship and qualify. **Verify:** a 20 clip fixture with
      J and L cuts, a dissolve and markers survives the trip both ways
      frame-exact; the sequencer render's frame count equals the timeline's.
- [ ] **F.17.03** Live shots in the cut: scene strips, with 5.2's view layer
      selector, play current layout and animation with no render, and swap to
      rendered media by version policy. **Verify:** a swap keeps the cut points;
      a missing render shows a slate and never an older version silently.
- [ ] **F.17.04** Assembly by the agent: script order, the shot list and takes
      become a first assembly with handles; cut points come from F.11.02's
      phrase boundaries, with J and L cut proposals; music onsets mark montage
      beats. **Verify:** every script line appears once unless annotated; cut
      points sit on aligned boundaries; the assembly is a proposal and never
      overwrites a person's cut.
- [ ] **F.17.05** Editing operations as skills on the timeline: insert,
      overwrite, ripple delete, roll, slip, slide, retime and swap take, with
      audio kept in sync through connected strips (5.2's `.connections`).
      **Verify:** hand-computed fixtures per operation; sync holds after
      ripples.
- [ ] **F.17.06** Dailies and cut review: rule checks first (flash frames, jump
      cuts from F.06.04's setup data, black gaps, audio gaps, duplicate frames),
      then a low-resolution review render to a video-input critic for pacing and
      continuity notes on timecode. Astra cannot take this role. **Verify:**
      planted defects are found with no model; critic notes land on the right
      timecode; only `sfw_only` material reaches a hosted model.
- [ ] **F.17.07** Interchange out: EDL, FCPXML and AAF through pinned
      OpenTimelineIO adapters for finishing elsewhere. **Verify:** an exported
      EDL re-imports with the same events; an unsupported feature is reported
      and never dropped silently.
- [ ] **F.17.08** Conform: when a shot version changes length, the cut, the
      sound and the captions follow, with a change list. **Verify:** a three
      frame trim reaches the audio clips and captions; the change list equals
      the difference between the two timeline versions.

## F.18 Sound: dialogue, effects, music and mix

Dependencies: F.17.01, F.11.01, F.00.02.

- [ ] **F.18.01** Spotting from script and picture: dialogue, hard effects,
      foley, ambience and music cues on timecode. A 3D film knows its contact
      frames exactly, so every footstep and impact in T.13.03's contact data
      gets a cue. **Verify:** no contact event lacks a spotted cue.
- [ ] **F.18.02** Generation through the audited audio and music lanes and
      F.11.01's dialogue, as versioned stems with licence rows that cover the
      output's use. **Verify:** every clip has lineage and a licence; an
      unadmitted model is refused.
- [ ] **F.18.03** Sync from 3D events: footsteps on contact frames, impacts on
      collision events from F.13, prop sounds on constraint cue frames, with
      level and low-pass from distance and occlusion to the camera. **Verify:**
      cues within one frame of their events; level follows the inverse distance
      law on a fixture.
- [ ] **F.18.04** Mix: dialogue, music and effects stems; music ducked under
      dialogue from the alignment data; pan from screen position; reverb from
      set size; loudness to an EBU R128 target with a true peak ceiling,
      measured with ffmpeg. **Verify:** integrated loudness and true peak of the
      master inside tolerance; the dialogue to music ratio during lines over a
      recorded floor.
- [ ] **F.18.05** Audio QA: clipping, DC offset, silence gaps, phase, sample
      rate and bit depth consistency, and sync drift from head to tail (the
      timebase rule of T.14.04 applied to 48 kHz against the frame grid).
      **Verify:** planted defects are caught; head and tail offsets are equal.
- [ ] **F.18.06** Captions in SRT and WebVTT from the aligned script and never a
      re-transcription, with reading speed limits, conformed with the cut;
      optional burn-in with the 5.2 Subtitles preset. **Verify:** caption times
      equal the alignment; characters per second inside limits; F.17.08's
      conform test covers captions.

## F.19 Colour grading, titles, delivery and quality control

Dependencies: F.14.03, F.17, F.18; F.00.03(f).

- [ ] **F.19.01** Shot matching before any look: balance across a scene from the
      chart proxies and linear statistics of F.12.02. **Verify:** grey and skin
      patch differences across a scene's shots under threshold after the match.
- [ ] **F.19.02** The look as an OpenColorIO look or a compositor strip modifier
      asset applied in the sequencer, checked headless with computed waveform
      and vectorscope statistics (5.2's HDR scopes are the artist's view of the
      same numbers). **Verify:** the look is identical in preview and render;
      legal range and gamut hold per deliverable.
- [ ] **F.19.03** Titles and credits: text strips with the style presets, and
      credits generated from the production's lineage so every licence that
      demands attribution gets it. **Verify:** each such licence in the register
      appears in the credits; text sits inside title-safe margins.
- [ ] **F.19.04** Deliverables from one master with pinned ffmpeg settings: a
      mezzanine (ProRes or an EXR sequence), web encodes (H.264, H.265, AV1), an
      HDR variant if decided, stems, captions, stills and the timeline.
      **Verify:** ffprobe matches each specification (codec, profile, rate,
      colour primaries, transfer and matrix tags, channel layout); duration
      equals the cut.
- [ ] **F.19.05** Final QC by rule: black and frozen frames, photosensitive
      flash limits, gamut and legal range, loudness, sync, caption conformance,
      file hashes, the content rating under A.04 and the provenance manifest.
      **Verify:** planted defects are caught; the QC report ships with the
      delivery.
- [ ] **F.19.06** Archive and rebuild: manifest, sources and a cache policy; a
      clean machine rebuilds a chosen shot to the same frame (CPU, fixed seed,
      which T.10 measured as byte-deterministic) or within tolerance on GPU.
      **Verify:** the rebuild proof runs on the Linux server.

## F.20 Film benchmark, studio surface, pilot film and closure

Dependencies: all of the above for the pilot; F.20.01 and F.20.02 start early.

- [ ] **F.20.01** A film benchmark with rule-based success, because none of the
      published Blender benchmarks measures film making: tasks per department
      ("frame a medium close-up at 50 mm", "repair the line cross in shot 12",
      "light to a four to one ratio", "sync line 7", "assemble scene 3", "master
      to the loudness target") in easy, medium and whole-scene tiers, on the
      cleared corpus of T.17.01. **Verify:** every task has a reference solution
      that passes and a planted wrong one that fails; no task is graded by a
      model alone.
- [ ] **F.20.02** Baseline on the cheap binding: the benchmark run with the
      repository's harness model as operator and one cheap vision model as
      critic. **Verify:** results with sample sizes; "the cheap model cannot do
      this department" becomes a measured row, which is what F.00.03(a)'s spend
      request cites.
- [ ] **F.20.03** Studio surface, extending T.15: script, breakdown, boards, a
      shot tracker with department status, a per-shot viewer with version
      compare, notes, locks, the cut player, and meters for controller tokens,
      GPU seconds and simulation hours. **Verify:** Chromium Playwright journeys
      on desktop and mobile that show real state, plus axe.
- [ ] **F.20.04** Director chat at film, sequence and shot scope: proposals
      arrive as diffs (shot list, camera, cut) that a person accepts or rejects,
      with steering mid-run (T.08.06) and the cost shown before a long run.
      **Verify:** accepting applies exactly the diff; rejecting leaves nothing
      behind.
- [ ] **F.20.05** The pilot film under F.00.03(c): 30 to 60 seconds, 6 to 12
      shots, two characters with one dialogue exchange, one set, one simulated
      effect, full sound, graded and delivered. Made once on the cheap profile
      and once on the Astra profile through the Codex lane, inside F.00.03(b)'s
      allowance and across as many windows as it takes. **Verify:** every F gate
      green for the pilot; a cost table of tokens by department and model, USD
      for billed models, allowance and windows for the Codex lane, GPU seconds,
      wall time and human minutes; both films and the failed attempts kept.
- [ ] **F.20.06** Capability matrix, extending T.17.06: department by controller
      profile, each cell autonomous, assisted or manual, with measured success,
      cost and named failures. Organic modelling, topology and deformation, the
      weak spots of the public reports, are tested and not assumed. **Verify:**
      no cell is filled from a vendor demo.
- [ ] **F.20.07** Model and tool watch inside T.18's review: controller catalog
      and prices, Blender 5.3's release and what actually shipped, Lab MCP
      releases, new benchmarks. A new controller runs F.20.01 before anything
      routes to it. **Verify:** a dated entry per check; routing never changes
      without a run.
- [ ] **F.20.08** Closure: every F item checked or carrying a dated note that
      names its one blocker; the tracker state updated; a memory note written.
