create-multi-product-hyper-motion-ad

create-multi-product-hyper-motion-ad

Purpose

Higgsfield Marketing Studio's marketing_studio_video model has a product_ids field that the schema lies about — it's server-validated max 1 (validated 2026-05-19). Multi-SKU ads that show all N products in one MS call are impossible through MS. This molecule produces the equivalent output by:

1. Generating N pairs of single-product MS clips (one wide arrival + one close moment per SKU).
2. Building a shared end-card from a reference image via Nano Banana 2 (product flat-lay) + HTML hyperframe (typography overlay).
3. Generating one ElevenLabs music bed with vocals scripted so the outro lyric matches the end-card on-screen line (audio-visual sync hook).
4. Assembling via ffmpeg (per-clip normalization → concat → music overlay with loudnorm + fades).

The shipped output is one cohesive 25-30s vertical ad that features all N SKUs.

When to use

• Brand has 3+ SKUs that should be featured together (scent line, color line, flavor line).
• Brief mentions "scent wardrobe" / "match your mood" / "pick yours" / "which one are you" / "find your X" framing.
• Output format is paid-social 9:16 (Reels, TikTok, Meta Ads).
• Brand aesthetic is GenZ / beauty / CPG / fragrance — Pinterest-coded, lifestyle-driven.

Skip if:

• Brief is single-product → use the existing legacy higgsfield-ms-sizzle (single MS call, no compositing).
• Brand aesthetic requires hand-held UGC realism → use a UGC molecule instead.
• Multi-product but no individual hero moments needed → just generate N parallel single-product clips, no compositing into one master.

Composed Atoms

• extract-product-screenshots
• create-end-card-from-reference
• create-end-card-html
• create-music-elevenlabs
• stitch-videos-ffmpeg
• watch-and-refine
• export-video-final
• package-video-assets

This molecule also calls the Higgsfield CLI directly (no dedicated atom yet) for product registration, Hyper Motion generation, and Nano Banana 2 image generation. The workflow below shows the raw CLI calls.

How each atom is used:

Atom	Step	Notes
extract-product-screenshots	Step 0	Source product PNGs from brand's Shopify or PDP (if not user-supplied).
create-end-card-from-reference	Step 4	Reference-image → NB2 product layer + HTML text overlay. Sibling atom that itself composes create-end-card-html.
create-end-card-html	Step 4	Underlying Playwright renderer (scripts/render_hyperframe.py) invoked by create-end-card-from-reference.
create-music-elevenlabs	Step 5	Music bed with vocals + AV-sync lyric. Use scripts/compose.sh or the direct curl pattern.
stitch-videos-ffmpeg	Step 6	Per-clip normalize → concat → music mix → loudnorm.
watch-and-refine	Step 7	Frame-by-frame QC of the final master via /watch:watch.
export-video-final	Step 7	Final encode + delivery.
package-video-assets	Step 7	Local QuickTime + gooseworks presigned URL.

Tool & Script Paths

Everything this molecule invokes, with absolute or repo-relative paths so the agent picking it up does NOT re-derive them:

CLIs + external APIs

Tool	Path / endpoint	Used for
Higgsfield CLI	/opt/homebrew/bin/higgsfield	Product registration, MS Hyper Motion, NB2 image gen, model schema lookups
ElevenLabs Music API	POST https://api.elevenlabs.io/v1/music?output_format=mp3_44100_128	Music bed (with vocals + AV-sync lyric)
Fal proxy (fallback)	POST https://queue.fal.run/fal-ai/elevenlabs/music	If ELEVEN_LABS_API_KEY unavailable; uses FAL_API_KEY
ffmpeg / ffprobe	system	Normalize, concat, scale, mix, loudnorm, frame extract

Repo scripts (call directly — don't reinvent)

Script	Used for
skills/atoms/end-cards/create-end-card-html/scripts/render_hyperframe.py	Playwright HTML → mp4 render. Walks document.timeline.currentTime frame-by-frame.
skills/atoms/music/create-music-elevenlabs/scripts/compose.sh	Single-prompt music gen (wraps the ElevenLabs Music API).
skills/atoms/music/create-music-elevenlabs/scripts/compose_from_plan.sh	Structured composition-plan music gen (when you need explicit lyric sections).

MCP tools

Tool	Used for
mcp__gooseworks__get_upload_url	Presigned S3 PUT URL for master mp4 upload
mcp__gooseworks__get_download_url	Presigned S3 GET URL for shareable review link
mcp__gooseworks__write_file	Small text files (manifest, brief) to gooseworks workspace

Plugin skills (user-invocable)

Skill	Invocation	Used for
/watch:watch	python3 ~/.claude/plugins/cache/claude-video/watch/0.1.3/scripts/watch.py <mp4> --no-whisper	Frame-by-frame QC of master (catches viewport mismatches, brand drift, residual hallucinations)

Legacy validated patterns to copy from (do NOT modify; they're case studies)

Skill	What it shows
skills/legacy/higgsfield-ms-sizzle/SKILL.md	Single-product MS Hyper Motion validated recipe (Offbeast filet). The atomic unit this molecule scales N-fold.
skills/legacy/higgsfield-ms-stats/SKILL.md	Stat-stack variant (MS Hyper Motion with on-screen overlays).
skills/legacy/ad-studio/SKILL.md	Most important: end-to-end ad orchestration with "two human gates only" pattern. The autonomy/interaction model this molecule inherits.

Project case study (the validated run)

Path	What's there
touchland/video-03-third-place-tour/HOW_TO_MAKE_THIS_VIDEO.md	Step-by-step worked example, all 6 prompts, all costs, all timings
touchland/video-03-third-place-tour/LEARNINGS.md	15 issues we hit + fixes, with timestamps
touchland/video-03-third-place-tour/working/build_master.py	Reproducible assembly script — copy this pattern verbatim into new projects
touchland/video-03-third-place-tour/working/trios-plan.md	The full prompt brief for both Trio 1 (shipped) and Trio 3 (deferred)

Inputs

Required from the user / brief:

• N product PNGs (one per SKU). Touchland-style flat-button atomizer or similar product.
• Brand wordmark PNG (high-res, transparent background). Download from the brand's CDN if not provided.
• Master target duration (default 25-30s; 6 clips × ~5s avg + 3s end-card).
• Color palette per SKU (one dominant color per product).
• Reference image for end-card aesthetic (Pinterest, competitor ad, magazine spread).
• End-card on-screen headline (e.g. "WHICH ONE ARE YOU?", "MATCH YOUR MOOD", "PICK YOUR DROP").
• Per-SKU label vocabulary for the end-card (e.g. "main character" / "soft girl" / "after dark").
• Brand guardrails (no efficacy claims, etc. — see brand's own 08-creative-guidelines.md).

Interaction Protocol

This molecule is self-directing. When invoked, the agent picking it up follows this protocol — do NOT improvise the input-collection order, do NOT skip the human gates, do NOT fire paid API calls before the brief is locked.

The pipeline has 3 phases and 2 human gates, modeled on the skills/legacy/ad-studio precedent:

Phase A — Brief lock          [INTERACTIVE]      ── HUMAN GATE 0 (brief confirmed)
Phase B — Generation          [AUTONOMOUS]
   ├─ Prompt drafting + self-critique          ── HUMAN GATE 1 (prompts approved)
   └─ Parallel batch + end-card + music
Phase C — Assembly + delivery [AUTONOMOUS]      ── HUMAN GATE 2 (master shipped)

Phase A — Brief lock [INTERACTIVE]

On invocation, the agent should:

A1. Pre-fill what can be auto-detected. Don't ask the user for things you can scrape:

• If brand is given as arg, fetch https://<brand>.com/products.json?limit=250 for SKU candidates.
• Check <brand>/08-creative-guidelines.md for brand guardrails; load if present.
• Check <brand>/source/product-images/ for existing PNGs; use them if present.
• Check <brand>.com HTML for the official wordmark PNG URL (typically at cdn/shop/files/<Brand>_Logo*.png).
• Default master_duration_s to 26; default music.vocals to true per memory feedback_music_with_vocals_default.md.

A2. Present a single editable brief table to the user. Format as YAML in one message, mark gaps with ?:

brand: <auto or ask>
products:                # ask if not in source/, pre-fill from Shopify if available
  - { name: ?, pdp_url: ?, dominant_color: ?, micro_label: ? }
  - { name: ?, pdp_url: ?, dominant_color: ?, micro_label: ? }
  - { name: ?, pdp_url: ?, dominant_color: ?, micro_label: ? }
end_card:
  reference_image: ?      # must be user-supplied (file path or Pinterest URL)
  headline: ?             # must be user-supplied
  outlined_word: ?        # auto-suggest the pivot word in the headline
  bg_gradient_top: <auto from brand palette>
  bg_gradient_bot: <auto from brand palette>
music:
  bpm: 112                # default for GenZ pop-house; adjust per brief
  genre: <auto-suggest based on brand vibe>
  vocals: true
  outro_lyric: <auto = end_card.headline>
master_duration_s: 26
brand_guardrails: <auto-loaded from 08-creative-guidelines.md, else ask>
brand_wordmark_png_url: <auto-detected or ask>

A3. PAUSE. Do not proceed until the user confirms the brief or fills the gaps. HUMAN GATE 0: brief confirmed.

A4. Scaffold the project folder (per PROJECT_STRUCTURE.md 5-folder layout) and save the locked brief to working/brief.yaml.

Phase B — Generation [AUTONOMOUS, with one human gate]

B1. Register the SKUs in MS (raw higgsfield marketing-studio products fetch --url per SKU). Store UUIDs in working/brief.yaml. Idempotent — repeats dedup.

B2. Engine-health probe. ONE 4s/720p MS call (~20 cr). Per memory feedback_probe_first_then_batch.md. If status: completed → continue. If failed → surface failure with 3 options to user (retry / fallback to Seedance / abort), then PAUSE.

B3. Draft prompts with self-critique pass. Apply rules from Step 3 prompting section. Run 2-3 rounds of self-critique per memory feedback_higgsfield_wide_not_macro.md and root LEARNINGS.md #111. Produce v3 prompts for all 2N clips (N arrival + N moment).

B4. PAUSE. HUMAN GATE 1: prompt approval. Show the user all 2N v3 prompts as a table. Wait for: approved / tweak <id>: <new prompt> / abort. Do NOT fire any MS call without this gate (each call is ~20-30 cr).

B5. Fire the batch. 2N MS Hyper Motion calls in parallel as background jobs (--wait-timeout 15m each). Monitor for completion notifications.

B6. End-card generation (parallel with B5): per create-end-card-from-reference atom — NB2 product layer (no text) + HTML overlay rendered at design dimensions (1080×1920) then ffmpeg-scaled to output dims. Use the brand's official wordmark PNG.

B7. Music generation (parallel with B5 + B6): per create-music-elevenlabs atom. Default to vocals + AV-sync lyric. Sanitize prompt — NEVER include named artists (memory feedback_elevenlabs_artist_names_tos.md). If rejected, copy data.prompt_suggestion verbatim.

Phase C — Assembly + delivery [AUTONOMOUS, with final human gate]

C1. Normalize each MS clip in working/build/seg_<N>.mp4 — strip MS audio (-an, per memory feedback_ms_generate_audio_override.md), scale to output dims, force 24fps, yuv420p.

C2. Apply known-issue trims based on memory:

• Atomizer-product moment clips: trim front ~2.5s (spray-pump-cap residue, per memory feedback_veo_spray_nozzle_prior.md).
• Claw-machine prize beats: trim front ~2.5s if wrong-product hallucination detected by /watch:watch.

C3. Concat + music overlay + loudnorm via the build_master.py pattern (copy from touchland/video-03-third-place-tour/working/build_master.py, just swap the SEQ list).

C4. Run /watch:watch QC on the final master. Surface any catches (residual hallucinations, label drift, etc.) to the user in the next message.

C5. PAUSE. HUMAN GATE 2: final master approval. Provide:

• Local file path (auto-opens in QuickTime via open -a QuickTime\ Player <path>)
• gooseworks share URL (via mcp__gooseworks__get_upload_url + get_download_url)
• QC findings summary

Wait for: ship / fix <issue> / abort.

C6. On approval: finalize delivery — log run to working/run.log, archive prior versions to archive/, update project HOW_TO_MAKE_THIS_VIDEO.md with this run's specifics if new patterns emerged.

When to skip a gate

• Skip Gate 0 only if user explicitly provided a complete brief.yaml as the invocation argument.
• Skip Gate 1 only if the user invokes with --no-prompt-review (e.g., they trust the molecule on a brand they've shipped before).
• Never skip Gate 2 — final master always needs human approval before declaring done.

Workflow

The Workflow below is the technical detail for each phase of the Interaction Protocol. Cross-reference:

Workflow step	Protocol phase
Step 0–1	Phase A (brief lock + product registration)
Step 2	Phase B / B2 (engine probe)
Step 3	Phase B / B3–B5 (prompts + batch)
Step 4	Phase B / B6 (end-card, parallel)
Step 5	Phase B / B7 (music, parallel)
Step 6	Phase C / C1–C4 (assembly + QC)
Step 7	Phase C / C5–C6 (delivery)

Step 0 — Source the product images [Phase A]

If user provides PNGs, use them directly. Otherwise:

• Check <brand>/source/product-images/ first.
• If absent, scrape Shopify: curl -sL "https://<brand>.com/products.json?limit=250" → extract product handles → fetch PDP image URLs.

Save under <project>/source/product-images/<scent>/<hero>.jpg.

Step 1 — Register the SKUs in MS (one-time per brand) [Phase A / autonomous within A]

For each SKU:

higgsfield marketing-studio products fetch --url "<PDP URL>" --wait --json

Store the returned UUIDs. Repeat-fetches dedup, so this is idempotent.

⚠️ products create --image <upload_id> returns HTTP 405 — do not use; URL fetch only.

Step 2 — Engine-health probe (single cheap MS call) [Phase B / autonomous]

MANDATORY before batch.

higgsfield generate create marketing_studio_video \
  --mode "product_showcase" \
  --product_ids '["<one_product_id>"]' \
  --aspect_ratio "9:16" --duration 4 --resolution "720p" \
  --generate_audio false \
  --prompt "<short test prompt — first arrival clip works>" \
  --wait --wait-timeout 15m --json > probe_result.json

Cost ~20 cr. If status: completed with a result_url, the engine is healthy → proceed to Step 3. If failure, escalate to user (do NOT auto-fallback to Seedance — surface the failure first).

The probe's result mp4 can be reused as the first wide-arrival clip if it looks good. Don't throw it away.

Step 3 — Generate the 6 hero clips (parallel batch) [Phase B / requires HUMAN GATE 1]

Two clips per SKU = 2N total. Fire all in parallel as background jobs.

Prompting rules (CRITICAL — these were learned the hard way)

For ARRIVAL clips (wide, environmental, 6s):

Rule	Reasoning
Lead with 9:16 KINETIC WIDE	MS product_showcase has a strong macro prior. The wide instruction must be EXPLICIT and STRUCTURAL at the start of the prompt.
Add Bottle stays small; environment dominates, never a macro close-up.	Positive scale instruction beats caps negatives.
Direct the storyboard explicitly: 3-cut energy: (1) whip pan ... (2) fast tracking ... (3) quick dolly-forward ...	MS auto-fragments into a multi-cut storyboard. Controlling the cuts > fighting them.
Use kinetic camera language: whip pan, fast tracking, quick dolly, low-angle push. Avoid slow, drift, static	Slow language produces documentary-pace footage, wrong for GenZ ad energy.
Include a real human/lifestyle element (sneaker, hand, silhouette)	Empty environments feel sterile.
End with Label identical to imported product reference. No on-screen text.	Anchors label fidelity; suppresses MS's auto-end-card text.

For MOMENT clips (close, lifestyle, 4s):

Rule	Reasoning
9:16 macro product-only shot for <brand> <SKU> opening	Tighter framing is intentional here; the close is the wide-clip's payoff.
Share at least one prop with the paired arrival clip (e.g. same wavy ceramic tray in both T1-3 and T1-4)	Cohesion. The close should feel like a different angle on the same scene, not a scene change.
Avoid spray-action triggers on atomizer products: no spray, splash, land, bounce, pour	MS shares Veo's wrong-pump-cap hallucination on atomizer bottles.
End with Label identical to imported product reference. No on-screen text.	Same as arrival.

Full call template

higgsfield generate create marketing_studio_video \
  --mode "product_showcase" \
  --product_ids '["<product_id>"]' \
  --aspect_ratio "9:16" \
  --duration <4|6> \
  --resolution "720p" \
  --generate_audio false \
  --prompt "<prompt per rules above>" \
  --wait --wait-timeout 15m --json > clips/<beat_id>_result.json

Prompt self-critique pass (REQUIRED before submitting)

After drafting all 2N prompts, do 2-3 iterations of self-critique before submitting:

1. v1 → v2: Read each prompt with an adversarial eye. Does it use any "macro" or "tight" language? Any spray-action triggers? Any "slow" / "drift" language? Fix.
2. v2 → v3: Does each prompt have a real human element? A specific camera direction (not vague drift)? A relational scale instruction (not literal %)? Fix.
3. v3 → final: Does each arrival clip share at least one prop with its paired moment clip for cohesion? Does each prompt avoid named-artist references (saves issues downstream for music)? Fix.

This iteration discipline produced 2-3× better prompts than first-draft in the validated Touchland run.

Per-clip wall time + cost

• 4s clip: ~20 cr, 3-15 min
• 6s clip: ~30 cr, 3-15 min
• Total for 6 clips (3 arrivals × 6s + 3 moments × 4s): ~150 cr
• Concurrent limit: no explicit cap observed on MS. Fire all 2N in parallel.

Step 4 — End-card via reference-image pattern [Phase B / autonomous, parallel with Step 3]

Use the atom create-end-card-from-reference. Summarized here:

1. Source/select reference image. Pinterest, competitor ad, magazine spread. Save to <project>/source/references/.
2. Generate product layer via NB2. Input: N product PNGs. Output: flat-lay composite on a soft gradient background, NO TEXT in the prompt.
3. Design HTML hyperframe at 1080×1920. Layers: NB2 PNG as background-image + headline (one word outlined) + handwritten labels (Caveat or similar) + SVG arrows with marker-end + brand wordmark PNG.
4. Animation (3s total): static base → headline rises → labels fade-in staggered → arrows draw via stroke-dashoffset → logo + URL settle.
5. Render at 1080×1920 via Playwright, then ffmpeg-scale to 720×1280. Do NOT render at output dimensions — Playwright will clip the right 33%.

See atoms/end-cards/create-end-card-from-reference/SKILL.md for full details.

Step 5 — Music via ElevenLabs (with vocals) [Phase B / autonomous, parallel with Steps 3-4]

Default to force_instrumental: false for cinematic/product short videos. Instrumental-only feels generic; female vocals + AV-sync hook to the end-card line is the distinctive move.

export ELEVENLABS_API_KEY=$(grep '^ELEVEN_LABS_API_KEY' /path/to/gtm-goose/.env | sed 's/.*= *//')

curl -X POST "https://api.elevenlabs.io/v1/music?output_format=mp3_44100_128" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"<prompt>","music_length_ms":<duration_ms>,"model_id":"music_v1","force_instrumental":false}' \
  -o music/music_vocals.mp3

Prompt rules:

• NEVER reference named artists ("PinkPantheress meets X" → HTTP 400 ToS violation). Use genre + texture + BPM + structure descriptors only.
• Script the end-card on-screen line into the music's outro lyric. Example: if end-card says "WHICH ONE ARE YOU?", music outro at 22-26s should deliver "which one are you?" as the closing hook. This AV-sync is the highest-leverage music move.
• If rejected, the API returns data.prompt_suggestion — copy that sanitized version verbatim.

Cost: $0.40 per attempt. Per memory feedback_elevenlabs_music_decay.md, music tapers in 2nd half — if first render decays, apply loop-and-flatten in ffmpeg rather than re-rolling.

Step 6 — Assembly [Phase C / autonomous]

Single ffmpeg pipeline:

1. Normalize each segment (strip MS audio with -an, scale to 720×1280, 24fps, yuv420p, uniform timebase).
2. Concat via demuxer (write concat.txt, run ffmpeg -f concat -i concat.txt -c copy).
3. Overlay music + loudnorm:

ffmpeg -y \
  -i silent_master.mp4 \
  -i music_vocals.mp3 \
  -filter_complex "[1:a]aresample=async=1000,atrim=0:<dur>,afade=t=in:st=0:d=0.3,afade=t=out:st=<dur-0.5>:d=0.5,loudnorm=I=-16:TP=-1.5:LRA=11[mixed]" \
  -map 0:v -map "[mixed]" \
  -c:v copy -c:a aac -b:a 192k -shortest \
  finals/master.mp4

Audio rules:

• loudnorm I=-16 LUFS = ad-broadcast-safe.
• afade in 0.3s + afade out 0.5s = clean envelope.

Per-clip trim hints (if MS hallucinations linger):

• Atomizer moment clips often have wrong-pump-cap in the first ~2.5s → trim aggressively.
• Claw-machine / "prize" beats can show wrong product in opening seconds → trim to back-half only.

Save the assembly as a portable working/build_master.py script with Path(__file__).resolve().parent.parent pattern (per CLAUDE.md convention).

Step 7 — QC + delivery [Phase C / requires HUMAN GATE 2]

Mandatory /watch:watch pass on the final master. Per CLAUDE.md hard rules and validated this run (caught spray-cap residue + wrong-prize chute + clipped headline).

python3 ~/.claude/plugins/cache/claude-video/watch/0.1.3/scripts/watch.py \
  finals/master.mp4 --no-whisper

Then Read every frame the script lists (parallel tool calls). Look for label warps, wrong-product hallucinations, end-card clipping, brand drift across cuts.

Deliver via both local + gooseworks (per user review pattern memory):

open -a QuickTime\ Player finals/master.mp4

# AND:
# mcp__gooseworks__get_upload_url → curl PUT → mcp__gooseworks__get_download_url

Output

<project>/
├── HOW_TO_MAKE_THIS_VIDEO.md  ← per-project recipe (this molecule + brand-specific notes)
├── LEARNINGS.md               ← what went wrong + fixes for this brand
├── finals/<brand>-master-v<N>.mp4   ← shippable master
└── working/
    ├── trios-plan.md          ← all prompts (arrival + moment per SKU)
    ├── build_master.py        ← portable assembly script
    ├── clips/<beat>_<v>.mp4   ← per-clip MS outputs
    ├── endcard/{endcard.html, layer1.png, wordmark.png, endcard_3s.mp4}
    └── music/music_vocals.mp3

Quality Checks

• 6 clips × status: completed with valid result_url.
• Master duration matches plan ±0.5s.
• Audio loudness: ffmpeg -i master.mp4 -af loudnorm=print_format=json -f null - shows integrated LUFS within -16 ±1.
• Label fidelity: /watch:watch at 1 fps shows brand wordmark legible in every settled frame of every clip.
• End-card: headline fully visible, all arrows land outside their target bottles, brand wordmark + URL legible.
• AV-sync: when music outro hits the lyric, end-card overlay is on-screen.

Failure Modes

• MS engine silently broken. Probe (Step 2) returns status: failed or never completes. Escalate to user; don't proceed.
• product_ids rejected with >1. Server caps at 1. Compose externally — this whole molecule is the workaround.
• CLI mode rejected. Use the slug (product_showcase) not the label ("Hyper Motion") when calling via CLI. Opposite via MCP.
• Spray-pump-cap hallucination on atomizer-product moment clips. Trim ~2.5s off the front; do not re-render with negatives.
• End-card headline clipped. Render HTML at design dimensions (1080×1920), ffmpeg-scale to output (720×1280). Do NOT match Playwright viewport to output dimensions.
• ElevenLabs ToS rejection. Drop named-artist references; use data.prompt_suggestion verbatim.
• Music decay in 2nd half. Apply loop-and-flatten (acrossfade + acompressor + loudnorm) rather than re-rolling.
• MS auto-audio not strippable via flag. --generate_audio false is server-overridden; strip via ffmpeg -an in normalization step.
• Macro fatigue across cuts. Re-prompt with 9:16 KINETIC WIDE + Bottle stays small; environment dominates, never macro + explicit 3-cut storyboard.

Decision Rules

• N scents? 3 is the validated sweet spot (Trio 1). 4-5 works but tightens per-clip time and may compress the wide-arrival breathing room. >5 = consider running parallel masters (one per cluster).
• Vocals vs instrumental? Default vocals for cinematic/product/lifestyle ads. Instrumental only if the brief explicitly asks for it (e.g. VO is planned later).
• Master duration? 25-30s sweet spot. <20s skips too fast through the trio; >35s feels long for paid social.
• Wide arrival = 6s, close moment = 4s. Validated rhythm. Adjust ±1s per brief, but don't drop arrivals below 4s (MS min) or push above 8s (energy decay).
• Reuse the probe clip as T1-1? Yes if it looks good. Saves 20 cr.
• Same end-card for both trios? Yes if shipping multi-trio (saves design time). Different if the trios are stylistically far apart.

Cost + time

Step	Cost	Wall time
Probe (1 clip)	~20 cr	3-15 min
5-6 hero clips	~120-150 cr	8-15 min parallel
NB2 end-card layer	~$0.08	2-3 min
ElevenLabs music	~$0.40	1-2 min
HTML render + ffmpeg	free	2-3 min
QC + delivery	free	5-10 min
Total	~150-200 cr + ~$0.50	~30-45 min real-clock

Account for 1-2 re-render rounds at ~80 cr each if first batch needs revision.

References

• Validated 2026-05-20 on Touchland Power Mist (Trio 1, 3 scents, 25.96s master).
• Per-project case study: touchland/video-03-third-place-tour/HOW_TO_MAKE_THIS_VIDEO.md + LEARNINGS.md.
• Related atoms:
  • atoms/end-cards/create-end-card-from-reference/SKILL.md (Step 4 detail)
  • atoms/music/create-music-elevenlabs/SKILL.md (Step 5 detail)
  • atoms/end-cards/create-end-card-html/scripts/render_hyperframe.py (Step 4 render)
• Related memories:
  • reference_higgsfield_ms_product_ids_cap.md
  • reference_higgsfield_ms_mode_labels.md
  • feedback_ms_generate_audio_override.md
  • feedback_veo_spray_nozzle_prior.md
  • feedback_higgsfield_wide_not_macro.md
  • feedback_music_with_vocals_default.md
  • feedback_endcard_reference_pattern.md
  • feedback_elevenlabs_artist_names_tos.md
  • feedback_render_at_design_dim.md
  • feedback_probe_first_then_batch.md