Remix a video

Invocation: remix <video path | url | keywords | clone dir> [topic] [low | high] [auto].

Arguments: $ARGUMENTS — the reference (a video file, a link, search keywords, or an existing clone-<id> directory or its template/), optionally the new topic, optionally the tier low or high, and optionally auto. Resolve ~ and relative paths. Where the client does not fill $ARGUMENTS in, take them from the user's request.

SKILL_ROOT is the absolute path to the directory containing this SKILL.md. Resolve it from the installed skill location, never from the working directory. Run every script as node "$SKILL_ROOT/scripts/<name>.mjs" …. PROJECT is the clone directory (default ./clone-<id>/, <id> = <topic>-<kind> such as saas-launch-explainer); REPLICA is $PROJECT/replicas/<slug> (slug = short English name of the new topic). References live in $SKILL_ROOT/references/; read each one at the step that names it, not up front.

Two tiers

The tier decides how faithfully step 3 rebuilds the original.

A reused clone directory keeps its template's tier (tier in analysis/brief.json); high on a low template rebuilds step 3 at high. Record the tier in brief.json in step 2. Tell the user the tier in the first progress line, and at high that low exists for a quicker, rougher copy.

Sub-agents

You do the work yourself by default. A sub-agent starts with its own system prompt, tools and skill list (50–150k tokens before its first step) and has to rebuild what you already know, so it pays only where several of them run at once on work that needs no judgment from the whole film. Use one, when the harness has a sub-agent tool, exactly where a step says so:

• step 3 (high), boards: a template with 4 or more layouts — one sub-agent per layout, all in one message;
• step 5, sketches; step 7, checking each generated clip as it lands; step 9, checking final frames per scene group.

The split, the decomposition, element measurement, fonts, transitions, the structure and acceptance stay with you: they need the whole film, and handing them over returns work you then redo.

• Split by unit of work, never by board when boards repeat: one sub-agent per layout (it writes every board of that layout), per generated clip, per scene group. Launch independent ones in the same message so they run at once; at most 8.
• Every brief names: the files to read (only the sections the task needs, not whole references), the files it may write, the command that accepts the result, the round limit, and what to return — a short text result, never images or file dumps.
• A fast-tier task that fails its acceptance command twice goes to the strong tier with the files as they are; the acceptance bar never changes.
• Codex: spawn with fork_turns: "none" (a full-history fork rejects model overrides); where the session does not expose model / reasoning_effort, the sub-agent inherits yours.

Two modes

The goal is one pass to a finished film. In both modes the work is the same and every check below runs; the modes differ only in where the user is asked.

A stop is a confirmation, not a review session. Before each stop, every self-check of that stage has passed and its fixes are done — the user should only need to say yes. What a check cannot reach (a font with no open look-alike, a moving original shot the replica must regenerate) is stated as a known limit with its reason, never handed to the user as a question. If the user still asks for a change, make it, rerun the checks of that stage, and stop again.

auto mode. Needs the topic; ask for it if it is missing — the only question. Research the topic on the web (step 4) and use the user's materials if they gave any. Choose like a careful producer: replacements AI-generated from the brief (people as plausible new people, never a real person's likeness), copy written by you within the copy budget, the first recommended voice, the template's audio mode, free music, Giphy for reaction GIFs when its key is set, the economy tier for small pop-ups. A budget the user named ("under 200 credits", "under $5") is a hard cap: downgrade models, then move slots to code until the estimate fits; if it cannot fit, stop and say so. Without a budget, spend what the plan needs at economy-first defaults. Paid work runs without a stop, so state the estimate in one line when generation starts. Deliver with the same report, and say which choices you made.

How to talk to the user

• Speak the user's language for the whole run (the docs and files stay English). A film in another language does not change the language you talk in: show its copy with the meaning in the user's language. Plain words, one short progress line per step while scripts and generations run.
• Every example message, table and phrase in this skill and its references is a pattern, not text to paste. Write it in the user's language — an English-speaking user never sees Chinese, a Chinese-speaking user never sees English labels. Quoted trigger phrases (e.g. "just make it", "you pick") are things a user may say, in any language.
• Never show file names, field names, model codes, JSON or script output. Picture sources are AI video, AI image, GIF, animation, your material, digital human — in the user's language. Name providers by vendor: "MiniMax", "fal", "TapVid", "ElevenLabs", "GIPHY"; models by their product names ("Nano Banana", "Seedance 2.0 Fast").
• Show, don't open. Everything the user looks at lives in the review page: the original beside the template, the replica preview, the cost, the finished film beside the original, every version and every generated clip. After a change, rebuild it (review.mjs) and name the tab; never open loose video, audio or image files in an external player. The page opens in English with a Chinese switch in its header. Its tabs: Clone comparison, Replica preview, Storyboard & cost, Final cut, Assets. Name a tab in the user's language (as the page's Chinese view labels it for a Chinese-speaking user, and tell them the switch is top right).
• The user decides the content (plan mode). The new topic, which people / products / logos get replaced and with what, and the user's own materials come from the user. Never invent defaults. Only when the user hands the choice over ("you pick", "choose for me") offer 2–3 options, or pick one and say why. Production choices — language, audio mode, voice, music, GIFs vs AI pictures — you recommend and the user confirms.
• Look it up before asking. When the user's materials leave gaps — what the product does, its features, pricing, audience, real names, its logo, how its screens look, facts the copy needs — research it yourself with the client's web tools (web search, page fetch, the browser tool): the official site, docs, changelog, press kit, app-store page. Searching is a first try, not a replacement for asking: what you cannot find, or find only unreliably (a product with no web presence, an unreleased feature, the user's own photos), you ask the user for, together with what the user alone decides. Say in one line what you found and where; never present a guess as a fact.
• Infrastructure is not a question. Local, free tools (ffmpeg, the runtime, Whisper, yt-dlp) are installed without asking — say so in one line. Ask only what the user alone can decide, or what costs money.
• Clone first, then ask. Steps 1–3 rebuild the original and need none of the user's content decisions: do not ask about the replica before the template exists (stop 1 at high). Step 4 opens with all the questions in one message, when you can show what the original actually contains.
• Nothing is spent before stop 2 (plan mode). Steps 0–5 cost only time and tokens. Commands that call a paid API for a test (media.mjs check --live) need --spend and the user's yes; prices come from media.mjs prices <provider>, which spends nothing.
• Keys never enter the chat. If the user pastes one, tell them it is now exposed, ask them to revoke it, and use the password box (set-key.mjs) for the new one.

Step 0 — environment (every run)

1. node "$SKILL_ROOT/scripts/ensure-runtime.mjs" installs whatever is missing (Homebrew on macOS, winget on Windows) and the runtime; the first run downloads Chromium and can take minutes — say so. Only a missing: … last line (no package manager, or a manual step) needs the user: show what it printed.
2. node "$SKILL_ROOT/scripts/media.mjs" providers --json — read it with references/providers.md, quietly. whisper-local not ready → node "$SKILL_ROOT/scripts/ensure-runtime.mjs" --tool whisper-cli (local, free, first in the transcription order even when another vendor has a key; the model download falls back to a mirror on a slow network by itself). Keys and generation providers are not raised now; they come up in step 4, where they matter.

Step 1 — inputs

Reference video.

Search or download failed (no provider for that platform, login wall, refused): follow the fallback in references/providers.md — first, with the user's consent, browser automation in the user's own browser (they log in themselves; no paywall, DRM or captcha bypass; only the video they picked); else ask them to download it and give you the file. A Douyin / TikTok search the user wants regularly is a reason to offer a written provider (references/provider-authoring.md).

Keep the topic if the user gave one; ask nothing else yet (the search pick above is the exception — only the user can choose the video).

Step 2 — read the original, frame by frame

node "$SKILL_ROOT/scripts/intake.mjs" "$PROJECT" <video> — add --understand when a video-understanding provider is ready. Transcription runs through a ready provider or local Whisper (step 0). Besides the shots, strips and words, intake lists the original's sound effects (source/sfx.json, a clip per event).

Then read references/analysis.md and write $PROJECT/analysis/brief.json from the shot strips, overview, transcript and (when present) the understanding file. Times always come from source/timeline.json.

Step 3 (low) — the quick template

1. Write $PROJECT/analysis/shots.json following assets/schemas/shots.json, from the shot strips, the overview and the transcript: consecutive shots grouped into scenes that tile the film (a scene with a pixel or screen layer at most 15 s — split a longer shot with start / end), each with a one-line English role. The heart of the step is each scene's layers: look at the frame and decide which source builds each region — avatar (someone talking to camera), pixel (filmed picture), screen (a phone or desktop screen) or code (graphics the board draws: panels, charts, lists, cards) — with its box (read off measure.mjs grid; a split screen is two layers, a picture-in-picture a full-frame layer then a small circle / round one, a keyed presenter a backdrop then an avatar with cutout), a describe, and the people, products and screens the replica may replace (subjects, boxes in the layer). A new layout inside a scene starts a new scene. Order layers back to front; boxes are [x, y, width, height] in 0–1 of the frame (subjects use the layer's coordinates). Give layers unique keys: presenter for the single avatar layer, other names excluding texts and say for the rest. Then every designed on-screen text with its box (read off measure.mjs grid), in / out in source seconds, entrance, colour and plate. Burned-in captions of the narration are not texts: their look goes into captions (references/captions.md tokens). One open font that looks like the original's text, picked by eye; a palette from the frames.
2. node "$SKILL_ROOT/scripts/quick.mjs" "$PROJECT" writes the template (boards, transitions, design, narrative structure, element inventory), installs the font, extracts the reference clips and builds the previews.
3. node "$SKILL_ROOT/scripts/validate.mjs" template "$PROJECT/template" — fix shots.json and rerun quick.mjs --force until clean. Look at each board's preview frame against the original at a moment its texts show — template/boards/<Name>.png is taken there — beside the same moment of the original: every region in its place (code regions stay empty until the replica), text in its place, no overflow.
4. Write $PROJECT/report.md in a few lines: scenes and their layouts, what the quick template does not rebuild (measured element motion, sound effects, designed transitions), and that high rebuilds them.

No stop: go on to step 4.

Step 3 (high) — build the template (1:1)

Follow references/analysis.md → boards.md → transitions.md → structure.md → acceptance.md, each artifact on disk before the next. Read each reference once, when its step starts; the scripts' usage lines and these references cover what you need, so do not read plugin sources.

1. Split into boards (one per layout system, not per shot) and write the reasons into $PROJECT/report.md.
2. Decompose: structure vs topic, region roles, lists, layering; write analysis/boards.json with windows from timeline.json and per-slot crop / subjects.
3. Inventory every element (references/analysis.md §9) into analysis/elements.json: each instance's measured box (measure.mjs grid), in / out, entrance, idle motion, content motion, font role, sound effect, and behind for an element the person in a footage slot covers (references/boards.md §8). Then node "$SKILL_ROOT/scripts/measure.mjs" motion "$PROJECT" — it tells stills from GIF-like loops, screen recordings and stop-motion "boil", which decide the field types (a moving original picture is a video slot) and the boards' idle motion.
4. Transition table into template/template.json, measured from the soft windows.
5. template/design.js with the measured captions style (Design.captions, references/captions.md), then fonts: for every text role, measure.mjs fonts against a crop of the original with 6–12 open candidates, pick by eye, then node "$SKILL_ROOT/scripts/fonts.mjs" "$PROJECT" --family "<Family>" --weights 400,700 (--substitute for a non-open font; record the swap).
6. Boards, layout by layout. Write template/boards/<Name>.jsx / .json from its elements (measured boxes replayed per instance, idle motion, data-sfx on the elements that sound, whether and where captions show on this layout in meta.captions, the cutout layer for elements behind the person), run refs.mjs "$PROJECT" --only <Name>, build-boards.mjs "$PROJECT" --only <Name>, compare.mjs "$PROJECT" --only <Name>, read the rows and fix by element until the board passes, at most 5 rounds; open a compare image only for a row under 0.95. With 4 or more layouts and a sub-agent tool, give each layout to a fast sub-agent instead (brief in references/boards.md §7), all in one message: 2 rounds, then the strong tier takes over for up to 3 more.
7. node "$SKILL_ROOT/scripts/refs.mjs" "$PROJECT" for all slots; write one English describe per slot in template/refs/refs.json.
8. Narrative structure template/skill/SKILL.md and the rest of template.json (references/structure.md).
9. Swap test (second topic, min / max list counts, Chinese and 1.5× English text, every line half its length).
10. Acceptance (references/acceptance.md): full build-boards.mjs, then in one command (they are independent, run them in the background together) clock.mjs "$PROJECT", compare.mjs "$PROJECT" --fail-under 0.95 --timing (sound effects included) and validate.mjs template "$PROJECT/template"; then the element checklist (acceptance §7). Every failure is fixed or proven a known limit before going on; after a fix rerun only what it touches (compare reuses unchanged boards).
11. Finish $PROJECT/report.md.

Stop 1 — the clone (plan mode; auto goes straight on). node "$SKILL_ROOT/scripts/review.mjs" "$PROJECT" builds and opens the clone review: the template plays beside the original, in sync, with component frames and the template's sound effects. Tell the user in a few lines: how close it is (samples ≥ 0.95, timing within one frame), what was measured and rebuilt (fonts, element boxes, idle motion, captions, sound effects), and the known limits with reasons. Ask for a yes; then step 4.

Step 4 — write the replica

Read references/replica.md.

Research first. Before the questions, look up the topic and the user's product on the web (see "How to talk": official site, docs, press kit, app-store page) and write what you learn to $PROJECT/research.md — what it is, key features and numbers, audience, tone, brand colours, the official logo's URL, links to real screenshots or demo videos, each with its source, and what you could not find. The questions propose concrete answers where research found them and ask the user for the rest; step 4.4 writes the copy from it. An official logo or press-kit picture of the user's own product goes to assets/user/ as their material once the user confirms it is theirs (auto: when the topic names the product).

Now ask — one message, in plain words (auto: decide each point yourself as in "Two modes"). Start from what the original contains (from brief.json and the template): its structure in a line (e.g. "a presenter talks to camera; above her a title, four numbered steps, app screenshots and reaction GIFs; word-by-word captions"), then:

• the topic, if not given yet;
• for each person, product, logo or sticker in the original: replace with what, or drop. Ask for the user's own pictures (copied into $REPLICA/assets/user/ once step 1 below creates it); without one, AI can generate it from a description or a slot can be drawn as animation;
• the original's product screens (screenshots, screen recordings): offer three ways and recommend the first — you record their product (they log in once in a window you open, you do the rest; references/capture.md), they give you recordings or screenshots they have, or the screens are drawn as animation. Their choice stands: a "no" to recording means their files or animation, without asking again. Open nothing before they agree. In auto mode record only public pages or a product with a saved session; otherwise animation;
• the original's moving pictures (reaction GIFs, loops): real GIFs from GIPHY (free; needs a free GIPHY key) or AI pictures brought to life (paid per clip) — recommend GIFs for meme-style originals;
• the content of repeated parts in the new topic (e.g. the four steps), or whether you should draft it;
• production choices with your recommendation: language; audio mode (narration when the original has a voice-over, music-only when it only has music); in narration mode the voice — write $PROJECT/requests/voices.json = {"id":"voices-<lang>","capability":"speech.voices","params":{"language":"<lang>"}}, run it, propose 2–3 recommended voices close to the original's register and energy (one voice serves the whole film and every digital human);
• what generation can do right now (from step 0's providers list): what is ready, what is missing and its effect (references/providers.md degradation table), and the cheapest fix — one TapVid key covers most of it: they create one at https://tapvid.ai/developer/apikey, then node "$SKILL_ROOT/scripts/set-key.mjs" tapvid pops up a password box for it; a key they already have for another vendor: set-key.mjs <provider>; a service that is not built in: ask for its API docs and follow references/provider-authoring.md. set-key.mjs prints saved, cancelled or invalid-key (rejected three times — ask for a new key). With no generation provider at all the flow still works: every slot becomes animation.

Then:

1. node "$SKILL_ROOT/scripts/replica-init.mjs" "$PROJECT" <slug> --topic "<topic>" --language <lang>.
2. Replacement table (replace): every subject the user named. Ask now about any subject in the original the user has not decided on — unless they handed the choice to you. A presenter portrait whose head sits higher or lower than the original host's (more than 5 % of the height) is reframed for free with reframe.mjs (references/replica.md §2) — the template's pop-ups must not cover the face.
3. Invented product (only with the user's agreement): write $REPLICA/product.md first.
4. Rewrite every scene's narration and data from the user's brief and research.md (real features and numbers, nothing invented about a real product) within the field limits and within the copy budget: the original's pace in syllables per second × the scene's window (references/replica.md §4). Copy that is too long makes the film slow or long; validate.mjs replica warns per scene. List counts follow the topic.
5. Media plan per slot: source ai (mode reference / keyframe / text), code, user; product screens the way the user chose: a capture of their product (references/capture.md: log in once, storyboard, capture.mjs record, index, clip per slot — moving slots get the recorded span, still slots the 2× shot), their own files (indexed and cut the same way), or code; moving original pictures as GIFs (gif.mjs search / pick, references/replica.md §5) or AI clips; elements as code in $REPLICA/elements/; presenter slots as digital human (narration mode only). At low each layer is one slot: presenter stays a digital human; a pixel layer stays ai / reference with provider: "tapvid", model: "minimax-h3" when TapVid is ready (else leave both null), the replacements in replace and the prompt from references/replica.md §6 Low tier, and goes to keyframe when the identity gate in step 7 fails; a screen layer becomes user (their recording or screenshot) when it must be readable, otherwise it is treated like a pixel layer; a code layer is an element — write $REPLICA/elements/<Board>.<key>.jsx for the new topic inside the region its field's desc names. The texts items are the new copy, one per original text, in its place.
6. node "$SKILL_ROOT/scripts/validate.mjs" replica "$REPLICA/replica.json", then node "$SKILL_ROOT/scripts/media.mjs" plan "$REPLICA/replica.json" (read its warnings: a reference falling back to keyframe changes what the user sees) and node "$SKILL_ROOT/scripts/media.mjs" estimate "$REPLICA/plan.json" --json (per model: unit price, count, subtotal). Small, short pop-up pictures take the cheapest fitting model by themselves (economy tier); a model the user picks pins its slots.

Step 5 — preview material

At low there are no sketches or GIFs: only the code layers' elements, the music candidates and the self-check below apply.

Slots that need a sketch (an ai slot without a reference clip, every code slot): read references/sketches.md. One sub-agent per board writes all of that board's sketches ($REPLICA/sketches/<Board>.<path>.jsx) and checks each with node "$SKILL_ROOT/scripts/frames.mjs" "$REPLICA" --sketch <file> --duration <s> — rewrite if it fails the bar, at most 2 rounds. Without sub-agents, write them yourself.

GIF slots: search and pick now (free) — look at each contact sheet and take the candidate that says the line best; avoid the very GIF the original used.

Background music candidates now, free ones only (references/audio.md): the user's file, two composed scores, or a royalty-free search hit. A paid AI-music candidate is a cost row, made after stop 2.

Self-check before stop 2: validate.mjs replica clean (copy-budget warnings fixed), every moving original picture has a moving source, every product screen has its chosen source (a capture or the user's files, checked frame by frame, nothing private; or code), presenter headroom checked, the plan's warnings understood.

Step 6 — stop 2: the replica and its cost

node "$SKILL_ROOT/scripts/review.mjs" "$PROJECT" <slug> builds and opens the review page (auto: build it, do not stop). Then give the table, filled from the replica and the estimate — this pattern, written in the user's language:

Here is the replica. Generation starts (and costs money) once you confirm:

#	Role	On screen	Narration / copy	Source	Made by	Length	Est. cost
1	Opening	The original's push-in on shot 1, with your photo as the person	How many hours does your team spend in meetings each week?	AI video (from the original)	MiniMax	2.1s	$0.28
2	Pain point	Three data cards popping in one by one	—	Animation	—	4s	0

Cost by model:

Use	Model	Unit price	Count	Subtotal
Pop-up pictures	Nano Banana (small pictures use the cheaper model)	6 credits / image	12	72 credits

Audio: narration (paced like the original, about 6.4 syllables a second) + music (2 options) + sound effects where the original has them; captions: same style as the original Total about $1.52. The review page is open; in Replica preview, tick "Compare with original" to play both

TapVid costs read as credits, every other vendor in dollars, totals per vendor. Name low-resolution and fallback rows plainly ("not sharp enough", "made from a new first frame").

Changes to copy, counts, replacements, a slot's source or vendor, voice, music: update replica.json and the sketches → plan → estimate → rebuild the review → ask again. Template faults: back to step 3 for that board, rebuild, ask again. Wait for an explicit yes.

Step 7 — generate the pictures

1. Narration mode, voice first so clip lengths fit:
   • a digital human that speaks the script itself (the plan then writes no separate narration take) is generated first: media.mjs run "$REPLICA/plan.json" --only <avatar ids>,<image ids> — the replacement images and keyframes go in the same run, since no length depends on them (one run at a time: the runner owns tasks.json). Check each clip as it finishes against the original's presenter footage of that slot (inspect.mjs, below): framing, the person, and nothing in the picture the original's footage does not have — text the original's footage shows is fine, text it lacks (garbled subtitles, a drawn caption) is not. Regenerate only the failing clip; when the same line fails twice, rephrase that line (words such as "subtitles", "captions" or "text" can make the model draw them) and keep its meaning;
   • otherwise the narration takes: --only <speech ids>;
   • then node "$SKILL_ROOT/scripts/timing.mjs" "$REPLICA": it transcribes self-voiced avatar clips and lays the lines on their real words, measures the pace against the original and applies one uniform tempo for the whole film when the voice is slower (capped so a presenter never looks fast-forwarded), and prints both rates. Then media.mjs plan again (video lengths now follow the resolved scenes, transition overlaps included). Any change in total cost above 10 % is told to the user before going on (auto: noted).
2. node "$SKILL_ROOT/scripts/media.mjs" run "$REPLICA/plan.json". The runner orders replacement images → keyframes → videos, keeps ≤ 10 in flight and resumes from tasks.json; rerunning never pays twice.
3. Check before anything depends on it (references/replica.md §Checks): generated replacement images and the first invented-product screen, then every keyframe (subject swapped, hands, product shape) — a bad one is regenerated once (--only <id> after fixing its prompt) before its video runs.
4. Every finished clip, as soon as it lands (do not wait for the rest): a fast sub-agent runs node "$SKILL_ROOT/scripts/inspect.mjs" "$REPLICA" <request-id> and looks at each frame it lists at full size, returning pass, or the problem and a clean span: extra hands, wrong fingers, a morphing product, garbled text, clipping, the subject drifting back to the original, a digital human's pace drifting within its clip. Trim to a clean span that covers the slot; otherwise state the cost and regenerate once with the prompt fixed. Identity gate, on every clip that shows a person (references/replica.md §9): the original's person must not appear in any frame. inspect.mjs "$REPLICA" <request-id> --identity, look at every frame, then identity.mjs pass|fail "$REPLICA" <request-id> --saw "<whose face, where>"; render.mjs refuses the film until identity.mjs status "$REPLICA" is clear. A clip that fails is never trimmed or kept: it goes to keyframe, and the other reference clips of the film lose their verdict and are read again. Do not route a generated clip through source: user: that slot leaves the gate. Contact sheets and overviews do not count as this check.

Step 8 — voice, music, timing

Read references/audio.md and, in narration mode, references/captions.md.

• Digital human slots were generated in step 7 with the same voice.
• Music: render or fetch the chosen candidate at the final length (music-compose.mjs, or a one-off music.generate request), beat grid with beats.mjs; music-only cuts land on the original's beats.
• node "$SKILL_ROOT/scripts/timing.mjs" "$REPLICA" writes resolved (and the tempo). A narration that pushes a scene past its board's maxDuration is shortened and re-voiced.
• Sound effects need nothing: the template's elements carry them, so they follow the new timing.

Step 9 — render and deliver

1. node "$SKILL_ROOT/scripts/project.mjs" "$REPLICA" --final.
2. node "$SKILL_ROOT/scripts/validate.mjs" project "$REPLICA/project" — fix every error.
3. node "$SKILL_ROOT/scripts/frames.mjs" "$REPLICA", then fast sub-agents (one per group of scenes) look at every scene midpoint, the frames around every line boundary, every transition's start / middle / end and the contact sheet — text overflow, two texts overlapping (captions included; frames.mjs also scans the film for this and exits 1 listing each pair), captions covered, a pop-up over a face, jumps at boundaries, sound vs picture. Fix and repeat, at most 3 rounds.
4. node "$SKILL_ROOT/scripts/render.mjs" "$REPLICA" → $REPLICA/out/tapvid.mp4 (1080p). Check the render: its length against the original's, the pace line timing.mjs printed, and frames sampled across the film, including the first second of every scene that shows a person, frame by frame at full width: a midpoint never sees an original person who is only in a scene's opening frames. A slot that went back to generation counts as done only when its request completed: a failed request leaves the old clip under the same file name. Alternative versions the user asks for go to out/tapvid-<what>.mp4; tapvid.mp4 is always the current one.
5. node "$SKILL_ROOT/scripts/review.mjs" "$PROJECT" <slug> again: the Final cut tab plays the film beside the original with a version picker, the Assets tab every generated clip with its vendor and cost.
6. Write $REPLICA/report.md (actual cost per vendor and model from media.mjs spend "$REPLICA", slots that fell back to animation, each asset's vendor, licenses and credits of stock footage, GIFs and music). Tell the user: the film is in the review page's Final cut tab (and where the file is), its length, what it actually cost per vendor, what became animation and why, and that the template folder can be reused next time — give them the template path to pass in for a new topic.

Later edits stay in the same replica: copy or code changes rerun only the affected part of steps 8–9; new paid media needs the cost stated and the user's yes first (auto: within the budget).