v0.2.0 to v0.3.0

+ version: "0.3.0"

+ description: Generate a product hero still, storyboard frames anchored to it, and native-1080p video clips on the local DGX Spark with the cinefoundry CLI (ComfyUI running Qwen-Image, Qwen-Image-Edit, LTX-2.5 Fast NVFP4 by default or Wan2.2, and RIFE interpolation to the delivery frame rate) instead of a cloud API. Use when product shots, storyboard frames or shot clips must be produced, when material is confidential or unreleased, or when choosing between local and cloud generation.

+ - ltx-2.5

+ - rife

+ Hero still first, frames second, clips last, interpolation after. Each step is anchored to the one before it, so product identity is decided where a retry costs seconds, not minutes. The default film is a 30-second master: six storyboard shots, so six frames and six 5-second clips, generated at native 1080p and interpolated to 60 fps.

+ ## Before every GPU phase

+

+ 1. Check memory with `spark-model-scheduler`. One diffusion family resident at a time; `cinefoundry mem free` when switching between them. The harness does this at every phase boundary (`enterPhase`) and puts the language models to sleep for frames and clips.

+ 2. **Evict the page cache of the model files.** On DGX Spark CUDA can only allocate memory that is truly free (`MemFree`), not what Linux counts as available: `MemAvailable` includes the page cache, and every model file just read from NVMe - tens of GB of safetensors - sits there looking reclaimable. With a warm cache a video model load can fail, or sample with far less room than `cinefoundry mem status` suggests. Compare the two, and drop the cache when the gap is large:

+

+ ```bash

+ grep -E '^(MemFree|MemAvailable|Cached):' /proc/meminfo

+ sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'

+ ```

+

+ Do it after `cinefoundry mem free` and before the video phase above all: LTX-2.5 at native 1080p is the largest allocation of the film.

+

+ 1. Generate the **product hero still** from the storyboard's `product` description on a plain backdrop, and gate it:

+ cinefoundry qa --frame projects/<id>/refs/product.png --expect "one product, fully visible, label reads \"<brand>\" clearly"

+ If the user supplied a photo of the real product (`--product-image`), it is the hero: skip this step.

+ 2. Generate every storyboard frame **from the hero still**. A reference switches the request to the edit model and keeps the product the same product:

+ Generate two candidates per shot (the harness's `--candidates`, default 2) and let `shot-quality-gate` pick: the spread between seeds is often larger than what a prompt edit buys.

+ 3. Only gated frames move on. Generate each clip from its approved frame, one per shot:

+ Drop `--keep-loaded` on the last clip so the video model is released. Always pass `--ratio`: the standalone command defaults to 9:16.

+ 4. Above 24 fps the harness interpolates every clip with RIFE 4.26 to a master of about 120 fps (24 fps x5; Wan2.2 14B's 16 fps x8) once the video model is freed, and the cut conforms it to the delivery rate by dropping frames evenly - so 60 fps lands exactly on the generated motion.

+ 5. Every command prints measured `seconds` and records the asset with `execution: local-dgx-spark`. Keep these numbers for the delivery report; never replace them with an estimate.

+ 6. Clips are saved near-lossless (H.264 crf 12 through ComfyUI's `format.codec.encoding.crf`). Never re-encode an intermediate at a lower quality - every generation of compression shows in the final grade.

+ | Step | Model | Measured |

+ | 5 s clip, native 1080p, from a first frame | **LTX-2.5 Fast 22B NVFP4 (default, `ltx25-fast-nvfp4`)**, sampled at half size and doubled by its latent upscaler | 247 s (2026-10-17, 1088x1920, 121 frames) |

+ | 120 fps master from a 24 fps clip | RIFE 4.26 (ComfyUI `FrameInterpolate`, x5) | 49 s per 1080p clip |

+ | 5 s clip, 720p, from a first frame | Wan2.2 I2V A14B fp8 + 4-step LoRAs (`wan22-14b`, 16 fps) | 353 s |

+ | 5 s clip, 720p | Wan2.2 TI2V-5B (`wan22-5b`, also text-to-video) | 365 s |

+ Native 1080p is the generation ceiling: `2k`, `4k` and `6k` deliveries are generated at 1080p and upscaled in the cut, and the delivery report says so. LTX-2.5 samples at half size and its latent upscaler doubles it, so 1080p frames are 1920x1088 (both halves divisible by 32). The total time of a film comes from its run log, not from multiplying this table.

+ - **Never ask the image model for captions or slogans.** Titles and subtitles are typeset in the cut. Measured failures: a caption painted twice, the style token "50mm" painted as text, a rare brand character drawn as a common look-alike. The only lettering in a frame is the product label, and it comes from the hero still.

+ - Keep numbers and lens specs out of image prompts for the same reason (code strips them from the style line).

+ - The video models want one camera move and one action, described plainly. For product-only shots end the prompt with "No people and no hands enter the frame" - otherwise they tend to add a hand reaching for the product. Code appends the category's motion rules and a cinematic-motion clause to every clip prompt, and the category's negatives to the negative prompt.

+ - CUDA out of memory, allocation failures in the GPU driver log, or heavy swapping: more than one diffusion family is resident, or the page cache is holding the memory CUDA needs. `cinefoundry mem free`, drop the page cache, then follow `spark-model-scheduler`.