cueframe 0.2.0 → 0.3.1

package/skills/extracting-brand-kits/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: extracting-brand-kits
+description: Use when the user says "make my video look like THIS" with a reference video, screenshots, or a moodboard — build a CueFrame brand kit FROM that inspiration so every subsequent compose speaks its visual language. Owns the extraction step: sample the reference's graphics-bearing frames, upload them as exemplars, reproduce each recurring motif as an authored graphic verified against the reference, and upsert the kit with the full language payload. Triggers on "match this style", "like this reference", "use this video as inspiration", "extract a brand kit", "moodboard". Hand off to cueframe-storyboard/composing-video once the kit is bound.
+---
+
+# Extracting brand kits: reference pixels → a kit the engine honors
+
+## The one idea
+
+**No summarization anywhere in the path.** A reference described in prose converges on house style
+with the reference's palette — the pixels are the ground truth. You (the agent) are the extractor:
+you SEE the reference, curate its frames, and reproduce its motifs as ordinary authored graphics,
+verified against the reference by looking. The kit you produce carries (a) **exemplar frames** the
+compose maker and judge both see, and (b) **motif skins** — card HTML the designer reproduces —
+plus code-checked facts (caption profile, density, palette). Once bound to a project, the engine
+takes over: the planner plans to your density, the designer sees your exemplars
+(`view_style_reference`), the judge grades every candidate against them, and a half-applied kit
+fails the compose loudly instead of shipping house style.
+
+Everything below drives the public `/v1` API with your API key. Frames never pass through chat —
+they go straight to storage via presigned PUTs.
+
+## 0. Prereqs
+
+- An API key with `projects:write` (create_brand_kit gates on the `brand_kits` plan feature — check `get_account` first; 402 names the feature).
+- `ffmpeg` locally, and the reference video file (download it first if it's a URL).
+- Know the org's IDENTITY kit if one exists (`get_profile` → brandKits). Inspiration NEVER overwrites identity: logo, brand fonts, and identity color slots come from the existing kit (or stay for the user to fill) — extraction contributes the LANGUAGE only.
+
+## 1. Sample the reference (local, ffmpeg)
+
+Uniform sampling misses short-lived graphics (1–3s overlays). Sample two ways and union:
+
+```bash
+# scene cuts
+ffmpeg -i ref.mp4 -vf "select='gt(scene,0.22)',showinfo" -vsync vfr scenes/%03d.jpg
+# 2fps sweep (catches overlays that appear without a cut)
+ffmpeg -i ref.mp4 -vf fps=2,scale=720:-1 -q:v 4 sweep/%04d.jpg
+```
+
+Then LOOK at the frames and curate: keep the **graphics-bearing** ones — frames where a card,
+pill, stat, lower-third, caption treatment, or end-card is visible and sharp. Drop near-duplicates.
+**≤24 frames**, each downscaled to ≤720px width, jpeg. For each animated graphic, also note the
+timestamp where it ENTERS (you'll classify its motion in step 5; re-watch that 1s window at
+`ffmpeg -ss <t> -t 1 -i ref.mp4 -vf fps=12 burst/%02d.jpg` if you need to see the entrance).
+
+Optional but recommended: build a contact sheet for the human's "right vibe?" check:
+`ffmpeg -i frames/frame-%02d.jpg -filter_complex tile=6x4 sheet.jpg`.
+
+## 2. Upload the exemplars (the ingest door)
+
+```
+POST /v1/brand-kits/exemplar-uploads  { "count": <n>, "includeContactSheet": true }
+```
+
+Returns presigned PUT slots under the org's `brand-inspiration/…` prefix — the ONLY namespace the
+kit door accepts exemplar keys from. PUT each curated frame (order matters: frame-01 ↔ index 0 —
+motif `evidence` arrays reference these indexes), PUT the sheet, keep the returned `key` list.
+URLs expire in 15 minutes; re-POST for a fresh batch if you run over.
+
+## 3. Inventory the motifs
+
+Look across the exemplars and list every RECURRING graphic treatment (expect ~5–12 for a designed
+reference). For each, write:
+
+- `id` — `m1`, `m2`, …
+- `observed` — one precise sentence ("thin-outline rounded keyword pill, single word, beside subject").
+- `role` — the closed vocabulary the planner/designer speak (exact values):
+  `title-card | stat | lower-third | pull-quote | hero | logo-tag | enumeration | sequence | comparison`.
+  Pick the role each motif best SERVES — the designer's steering matches on it exactly.
+- `evidence` — the exemplar indexes (0-based) it appears in.
+- `zone` — normalized `{x, y, w, h}` where it lives.
+- Behind-the-subject motifs (text the speaker occludes): record them with `coverage: "skipped"` and
+  `skipReason: "behind-subject — card graphics render front-only"`. Do NOT attempt them.
+
+Also read the CAPTION treatment off the frames (step 6 consumes it): plate or plateless? base/
+highlight colors? case? emphasis styling? entrance feel (~ms)?
+
+## 4. Reproduce each motif as a card (author → look → refine, ≤3 iterations)
+
+For each non-skipped motif, author it as a **card** (freeform HTML/CSS — rendered verbatim) and
+verify it against the exemplar BY LOOKING:
+
+1. **Measure first**: read the exemplar — border weight, radius, padding, font size relative to
+   frame, colors. Measurement-seeded CSS gets you ~90% in one shot.
+2. Author `{ "kind": "card", "html": "…", "tokens": { … } }`. Bind every brand-swappable color
+   through `tokens` with `$brand:` refs (e.g. `"line": "$brand:colors.accent"`, referenced in CSS
+   as `var(--cf-line)`) so the kit's identity re-themes it. No `<script>`, no `@keyframes` (inert —
+   motion is step 5).
+3. Render it (`preview_frame` on a scratch session, or `preview_component` if you forked a
+   component) and compare the still against the exemplar side by side. Fix the largest visible
+   difference. Repeat — **cap 3 iterations**, keep the best.
+4. Record `diffScore` (your honest 0–1 same-language judgment) and `coverage`:
+   `"reproduced"` (≥0.8) or `"approximated"`.
+
+Prefer a catalog primitive (`list_catalog`) over a card ONLY if it genuinely matches closer —
+record it as `{ "kind": "overlay", "primitiveId": "…", "params": { … } }`. A custom component
+(`{ "kind": "component", "componentId": "…" }`) only for motifs with internal motion (counters).
+
+## 5. Classify motion (closed vocabulary — never invent animation)
+
+Watch each motif's entrance burst and map it:
+
+- Graphic motion presets (exact values): `fade-up | slide-in-left | slide-in-right | scale-pop | stagger-reveal`,
+  with `enterMs` / `exitMs` / `staggerMs` timings you observed.
+- Caption per-word entrances: `none | fade | word-pop | stagger-up`.
+- Unsure or the reference does something the vocabulary can't say? Pick the NEAREST preset and set
+  `"confidence": "low"` — honesty beats fabrication; the vocabulary grows engine-side, not here.
+
+## 6. Compute the facts
+
+- `captionProfile` — from step 3's caption read. The kit door speaks the full look: `color`,
+  `highlightColor`, `plate` (`"none"` for the clean plateless look), `entrance`, `entranceMs`,
+  `exitMs`, `emphasisColor/Scale/FontWeight/FontStyle`, `emphasisPlate` knobs, `textTransform`.
+- `density` — `{ "graphicsPerMin": <count/duration*60>, "maxSimultaneous": <max overlapping> }`.
+- Palette → `extraColors` entries `{ "hex", "label": "inspiration accent N", "usage": "swappable" }`.
+  NEVER write the identity `colors.*` slots, `headingFont`/`bodyFont`, or `logo` from the
+  reference — copy those from the base identity kit, or leave them for the user.
+- `styleRubric` — 2–4 sentences the JUDGE will grade with: name the motif language, the caption
+  treatment, and what disqualifies a frame ("filled chips or plated captions are off-language").
+
+## 7. Upsert the kit + bind it
+
+One `create_brand_kit` call (it's an upsert — re-POST the same `kitId` to curate):
+
+```jsonc
+{
+  "kitId": "acme-launchfilm",
+  "name": "Acme × Launch Film",
+  // identity: copied from the base kit or neutral — never from the reference
+  "colors": { … }, "headingFont": { … }, "bodyFont": { … },
+  "extraColors": [ { "hex": "#F5B942", "label": "inspiration accent 1", "usage": "swappable" } ],
+  "captionProfile": { "plate": "none", "entrance": "fade", "entranceMs": 220, … },
+  "exemplarKeys": [ "<keys from step 2, in frame order>" ],
+  "contactSheetKey": "<sheet key>",
+  "motifs": [ { "id": "m1", "observed": "…", "body": { "kind": "card", … }, "motion": { "preset": "fade-up", "enterMs": 320 }, "role": "pull-quote", "zone": { … }, "evidence": [0, 2], "diffScore": 0.93, "coverage": "reproduced" } ],
+  "styleRubric": "…",
+  "density": { "graphicsPerMin": 4, "maxSimultaneous": 2 },
+  "inspiration": { "sources": ["<reference URL>"], "extractedAt": <now ms>, "extractionVersion": "skill-1" }
+}
+```
+
+The door validates loudly: exemplar keys must come from step 2's batch, motif roles/presets must be
+in-vocabulary, evidence indexes must be in range. A 422 names exactly what to fix.
+
+Then bind: `update_project { "brandKitId": "acme-launchfilm" }`. Show the human the contact sheet
+("right vibe?") before composing. From here, hand off to **cueframe-storyboard** — every compose
+against the project now plans, designs, and JUDGES in the reference's language, and refuses to
+ship house style if any part of the kit fails to resolve.
+
+## Failure honesty
+
+- Reference has no graphics language (talking head, zero overlays)? Say so — upsert nothing, or a
+  captions-only kit. Don't invent motifs.
+- A motif you can't match in 3 iterations ships as `"approximated"` with its real diffScore — the
+  judge's floor will surface it; don't inflate.
+- Behind-subject motifs stay `"skipped"` with the reason. The engine refuses them loudly anyway.

package/skills/launch-video/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: launch-video
+description: Turns screen recordings and product footage into a 30–90 second 16:9 launch film — payoff-first hook, real product surface punched in, a building bed or narration, one CTA end card. Triggers on "make a launch video", "announcement video for this feature", "turn this screen recording into a demo film", "product video from these captures", "we're shipping Friday and need a video", "feature announcement".
+---
+
+# Launch video
+
+You bring real screen recordings or product footage plus the one outcome the feature delivers;
+you get back a 30–90 second 16:9 announcement that opens on the payoff, shows the actual product
+doing the real thing, builds under a bed or narration, and lands on a single CTA.
+
+## Before you start
+
+Nail the payoff sentence and collect the captures before any setup. When the first tool call
+approaches and CueFrame isn't connected:
+
+- **Claude Code:** offer to run
+  `claude mcp add --transport http cueframe https://api.cueframe.ai/v1/mcp` — browser OAuth,
+  one **Allow**.
+- **Claude.ai / Claude Desktop:** Settings → Connectors → add a custom connector with
+  `https://api.cueframe.ai/v1/mcp`.
+- **Other agents (Cursor, Codex, VS Code, Windsurf, Zed, Gemini CLI, Copilot CLI, …):**
+  run `npx -y cueframe install` — it detects what is on the machine and wires each one.
+- **ChatGPT:** the CLI cannot wire it (there is no local config to write) — add
+  `https://api.cueframe.ai/v1/mcp` as a custom connector instead.
+
+Keep the momentum — the video plan is the hard part, the connection is not.
+
+## Inputs
+
+- **Real captures** (required): screen recordings, product footage, real output. CueFrame does
+  not screen-record — the user records (or uses a capture client) and you `import_media` the
+  file. Never mock what's missing; ask for the real capture.
+- **The payoff**: the outcome in the user's words ("close the books two days faster"), plus the
+  CTA (one action) and launch date if any.
+- **Brand kit**: project kit if present; ask for wordmark + accent color otherwise.
+- **Voice**: default a building instrumental bed with captioned key lines; narrated VO if they
+  have a script or want one generated.
+
+## Workflow
+
+1. **Import the real surface.** `import_media` every capture; wait for ready;
+   `get_media_context` for what each recording actually shows (and the transcript, if narrated
+   footage exists). Inventory the strongest 3–5 real moments before writing a beat.
+2. **Open on the payoff, not the name.** The hook is the OUTCOME — the result on screen, the
+   pain disappearing — inside the first seconds. "Introducing X" is throat-clearing; the
+   outcome-first frame is the hook. No logo, no title card first.
+3. **Structure: hook → problem → reveal → proof → CTA.** `new_composition` at 16:9 →
+   `apply_composition` with the beats. Pacing tightens as the payoff approaches — clips get
+   shorter toward the reveal.
+4. **Punch in on the real pixels.** A click target is tiny in a full-frame capture;
+   `setCropIntents` with `point` focus segments zooming to the exact UI region per step,
+   `frame-center` in the gaps, tiling every clip. The single biggest amateur-to-pro delta in
+   product video.
+5. **Cards for the claims and the end card.** Key lines and the closing CTA are `kind:"card"`
+   HTML in the brand's type and palette — persisted first, then shelled with
+   `applyMotionPreset` in a FOLLOWING `apply_composition` call. One CTA on the end card, held
+   long enough to read, plus the date if there is one.
+6. **Audio that builds — required.** `search_resources` for a bed honoring the brand kit's
+   `musicMood`, energy arcing toward the reveal; place it `audioRole:"music"`,
+   `materializeGrid { grid:"beat" }`, and land beat boundaries and the reveal on the grid. If
+   narrated: the VO is the rhythm authority instead — cut to the voice and duck the bed under
+   it. Silence is almost never right for a launch; if chosen anyway, record the decision and
+   reason in the delivery note.
+7. **Caption narration.** If there is a voice, `captions.fromTranscript` (or authored word
+   timings for generated VO), styled legible via `setCaptionStyle`. Captions are mandatory when
+   narrated.
+8. **Preview, judge, one render.** `preview_frame` at t=0, hook-end, the reveal, and the end
+   card; describe each still — is that a REAL capture on screen? Then `score_composition` with
+   the payoff line as `editorialIntent`; fix worst-first to ≥ 7.5; `create_render` →
+   `wait_job (kind:"render")`.
+
+## What good looks like
+
+Quoted from `video-craft-standards` §2 (Launch film / feature announcement) — the full checklist
+wins:
+
+> **MUST (K)** Payoff-first hook: the OUTCOME, not the feature name ("Close the books two days
+> faster" beats "Introducing the reconciliation module"). No throat-clearing.
+
+> **MUST** Narration or a bed that builds toward the reveal; pacing tightens as the payoff
+> approaches. **MUST** Real product surface: actual UI/screens/output — never mocked.
+
+> **MUST** End card with a single CTA. **MUST** Captions present when narrated.
+
+And cross-cutting: *"Footage carries the video: real footage / real UI / real data ≥60% of
+runtime for footage-first classes."*
+
+## Delivering
+
+Close with the handoff, never "done":
+
+- The render link and where it lives (project + composition id).
+- Attribution for the bed and any licensed asset (provider, id, author).
+- The intentional-silence note with its reason, in the rare case silence was chosen.
+- A one-line cutdown offer: the 16:9 master can become 9:16 / 1:1 siblings for social (see
+  `every-format-from-one-edit`).

package/skills/make-a-social-reel/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: make-a-social-reel
+description: Turns footage into a finished 9:16 social reel — hook inside 2 seconds, poster-grade type, a decided music bed, one final render. Triggers on "make me a reel from this", "turn this into a short", "cut a clip for TikTok / Reels / Shorts", "make this vertical", "make a social clip from this video", "the opening is boring", "can you make this pop for Instagram".
+---
+
+# Make a social reel
+
+You hand over footage (a file URL, a talk, a product moment); you get back a 9:16 reel of 8–30
+seconds that opens on its strongest image, cuts on the music, carries brand-grade type, and ends
+on a deliberate beat — with a download link, not a "done".
+
+## Before you start
+
+Don't stall the conversation on setup — get the footage, the hook, and the tone agreed first.
+When the first real tool call is imminent and CueFrame isn't connected:
+
+- **Claude Code:** offer to run
+  `claude mcp add --transport http cueframe https://api.cueframe.ai/v1/mcp` — a browser tab
+  opens and the user clicks **Allow**.
+- **Claude.ai / Claude Desktop:** Settings → Connectors → add a custom connector with
+  `https://api.cueframe.ai/v1/mcp`.
+- **Other agents (Cursor, Codex, VS Code, Windsurf, Zed, Gemini CLI, Copilot CLI, …):**
+  run `npx -y cueframe install` — it detects what is on the machine and wires each one.
+- **ChatGPT:** the CLI cannot wire it (there is no local config to write) — add
+  `https://api.cueframe.ai/v1/mcp` as a custom connector instead.
+
+Thirty seconds, then straight back to the reel — treat it as a detour, never a gate.
+
+## Inputs
+
+- **Footage** (required): a public https URL, or something already in `list_media`. If they have
+  nothing, ask for the real thing before reaching for stock — real footage is the whole edge.
+- **Brand kit**: use the project's kit if one exists; otherwise ask for a color + font or extract
+  one. Default: proceed with a neutral palette and say so.
+- **Tone / platform**: default punchy, 15–25s, sound-on-with-captions. Ask only if the answer
+  would change the cut.
+
+## Workflow
+
+
+0. **Find the claim (before anything else).** Interrogate the brand/material
+   for its tension — what it believes that its category doesn't — and write
+   the claim in one sentence. Derive the shot list, the bed's mood/tempo, the
+   pacing, and every card's copy FROM that sentence. If you cannot state the
+   claim, you are not ready to compose (video-craft-standards: the
+   controlling idea is kill-level).
+
+1. **Import and read the footage.** `import_media` (public https URL), poll `list_media` until
+   ready, then `get_media_context` — faces, transcript, word timings. The context tells you
+   where the hook lives; don't guess.
+2. **Pick the hook before you touch the timeline.** The strongest image, motion, or claim in the
+   footage — the outcome, not the feature name, is the hook. If the best moment is at 0:47, the
+   reel opens at 0:47. No logo-first cold opens, ever.
+3. **Seed the timeline.** `new_composition` at 9:16, then `apply_composition`: clips trimmed to
+   the beats you chose, a new visual beat at least every ~4 seconds. Cut TO moments; never let a
+   clip run out.
+4. **Reframe for vertical.** `setCropIntents` with segments that tile every clip —
+   `active-speaker` or `face` focus when a person carries it, `point` focus on the action
+   otherwise. A wide shot letterboxed into 9:16 is a fail, not a fallback.
+5. **Author the type as cards.** Brand text is `kind:"card"` HTML — your typography,
+   palette-as-fields, considered alignment — persisted first, then shelled with
+   `applyMotionPreset` in a FOLLOWING `apply_composition` call. Catalog text primitives are
+   utility only.
+6. **Decide the audio — required, never skipped.** Search a bed with `search_resources` honoring
+   the brand kit's `musicMood`, place it as an `audioRole:"music"` clip, then `materializeGrid`
+   `{ grid:"beat" }` and land your cut points and transition midpoints on the markers. If the
+   piece is genuinely better silent, that is a decision — record it and its reason in the
+   delivery note. A reel whose silence nobody chose is not done.
+7. **Caption any speech.** `captions.fromTranscript` with the mediaId, styled via
+   `setCaptionStyle` (plated, bottom, out of the mouth/eyes). Most social viewing is sound-off;
+   don't karaoke a beat with no speech.
+8. **Look, then get judged.** `preview_frame` at t=0, hook-end, and every beat boundary;
+   describe each still in words before scoring it. Then `score_composition` with your one-line
+   vision as `editorialIntent` — fix the worst criterion first. Ship at composite ≥ 7.5, budget
+   3–5 passes.
+9. **One final render.** `create_render` → `wait_job (kind:"render")`. Iterate with previews,
+   not renders.
+
+## What good looks like
+
+Quoted from `video-craft-standards` §1 (Social reel) — the full checklist wins over this skill
+wherever they disagree:
+
+> **MUST (K)** The hook lands inside 2 seconds: the strongest image, motion, or claim opens the
+> piece. No logo-first cold opens, no fade-in-from-black preambles.
+
+> **MUST** Typography is poster-grade: composed plates/fields in the brand palette, considered
+> alignment and scale. **K:** centered white text floating on footage.
+
+> **MUST** Pacing is cut-driven: a new visual beat at least every ~4s […] **MUST** Ends on a
+> deliberate beat: tagline, logo, or CTA lockup — not a clip running out.
+
+And the cross-cutting audio rule:
+
+> **MUST** Audio is decided, never defaulted […] **K:** a render whose silence nobody chose.
+
+## Delivering
+
+Never end with "done". The last message carries:
+
+- The render's download URL and where it lives (the project, by composition id).
+- Attribution for every stock asset used (provider, id, author) — the provenance you recorded at
+  import.
+- The intentional-silence note with its reason, if you chose silence over a bed.
+- One line on what you'd tighten next, so the follow-up edit has a starting point.

package/skills/rebrand-a-video/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: rebrand-a-video
+description: Swaps the brand kit under an existing video and re-renders — tokens, bumpers, logo, captions, and motion re-theme automatically; hardcoded card values get surgical edits. Triggers on "rebrand this video", "swap the brand", "we changed our colors", "new logo, same video", "make this video match the new brand", "re-theme our launch video", "white-label this for a client".
+---
+
+# Rebrand a video
+
+You bring a finished video and a new brand (a kit, a website, or new colors/fonts/logo); you get
+the same video back wearing the new identity — everything bound to brand tokens re-themes at
+render, and the few graphics that hardcoded the old brand get found and fixed. Change one line,
+not the whole video.
+
+## Before you start
+
+Collect the new brand's facts first — the swap itself is fast. When the first tool call
+approaches and CueFrame isn't connected:
+
+- **Claude Code:** offer to run
+  `claude mcp add --transport http cueframe https://api.cueframe.ai/v1/mcp` — browser OAuth,
+  one **Allow**.
+- **Claude.ai / Claude Desktop:** Settings → Connectors → add a custom connector with
+  `https://api.cueframe.ai/v1/mcp`.
+- **Other agents (Cursor, Codex, VS Code, Windsurf, Zed, Gemini CLI, Copilot CLI, …):**
+  run `npx -y cueframe install` — it detects what is on the machine and wires each one.
+- **ChatGPT:** the CLI cannot wire it (there is no local config to write) — add
+  `https://api.cueframe.ai/v1/mcp` as a custom connector instead.
+
+Then back to the brand — most of this job is a kit definition and an audit.
+
+## Inputs
+
+- **The video** (required): the composition (via `list_compositions`) and which project it lives
+  in.
+- **The new brand** (required): an existing kit id, a website to `extract_brand_kit` from
+  (colors/fonts only — ask for logo, tagline, voice), or explicit values for `create_brand_kit`.
+- **Same identity or a new one?** Restyling THIS brand → upsert the same kit id and every
+  composition pointing at it re-themes. White-labeling for someone else → a NEW kit, so the
+  original stays intact.
+- **Tone shift**: does the new brand change the music mood too? Check the kit's `musicMood`
+  intent.
+
+## Workflow
+
+1. **Pin the new brand as a kit.** `extract_brand_kit` or `create_brand_kit`; show the kit and
+   get sign-off — it is the contract. Then bind it: upsert in place (same kit id) to restyle,
+   or point the project at the new kit for a white-label. The kit lives on the PROJECT, not on
+   a composition op.
+2. **Know what re-themes for free.** Everything resolved at render: `$brand:` color/font/motion
+   tokens on overlays and cards, the kit's intro/outro bumpers, the logo corner mark, the
+   caption profile, the motion identity. Edit the kit, re-render, these all follow — that is
+   the whole "one line" story.
+3. **Hunt what does NOT re-theme.** Anything that hardcoded the old brand: literal hexes or
+   font names inside `kind:"card"` HTML, an old wordmark imported as media, footage graded
+   toward the old palette, baked stock choices that lived in the old world. Walk the
+   composition's overlay and card clips and list every literal value — this audit is the real
+   work.
+4. **Verify with pixels, not the kit.** Kit contents aren't inspectable over MCP after
+   creation, so the truth is the frame: `preview_frame` at t=0, each card, the bumpers, and the
+   end card. Describe each still — is any old color, font, or mark visible? A `$brand:` token
+   that fails to resolve is loud in render logs and falls to a legible neutral; a hardcoded old
+   hex is silent, which is why you hunt it by eye.
+5. **Fix the holdouts surgically.** `apply_composition` edits per offending clip: rebind card
+   fields to `$brand:` tokens (so the NEXT rebrand really is one line), swap the old-wordmark
+   media, re-grade footage toward the new palette. A replaced card gets re-shelled with
+   `applyMotionPreset` in a FOLLOWING call. The §3 test governs every card you touch: if the
+   old brand's hex would still look correct in it, the layout was never bespoke — rebuild it,
+   don't tint it.
+6. **Re-decide the audio — required.** A brand swap is a mood swap: check the bed against the
+   new kit's `musicMood`. Wrong mood → `search_resources` a replacement (license recorded),
+   same role and ducking, `materializeGrid` re-run if cut timing shifts. Still right → say so
+   in the delivery note. If the piece was intentionally silent, confirm that decision still
+   fits the new brand and restate it.
+7. **Judge against the NEW brand, render once.** `score_composition` with the new brand facts
+   as `brandContext` — the brand axis is exactly the check this job needs. Fix worst-first to
+   ≥ 7.5, then `create_render` → `wait_job (kind:"render")`.
+
+## What good looks like
+
+Quoted from `video-craft-standards` §3 (Brand-identity reel) — the bespoke test applies to every
+card in any class:
+
+> **MUST** Every graphic is bespoke to the brand: its type, its palette as fields, its layout
+> system. **K:** any layout that would look correct with another brand's hex swapped in.
+
+> **MUST** Footage color and brand palette agree — grade toward the palette or choose footage
+> that lives in it.
+
+And cross-cutting: *"**MUST** Brand/text graphics are AUTHORED — `kind:"card"` HTML (your
+typography, layout, palette-as-fields) […] **K:** a brand graphic rendered from a catalog text
+primitive."*
+
+## Delivering
+
+The last message closes the loop, never "done":
+
+- The re-rendered link and where it lives (project + composition id), plus the kit id now bound
+  — and the one-line promise made true: next time, edit the kit and re-render.
+- What re-themed automatically vs what you hand-edited (the audit list from step 3) — the user
+  should know which parts of their video are now token-bound.
+- Attribution for any newly licensed bed or asset (provider, id, author).
+- The audio decision: bed kept / bed swapped and why / intentional silence restated.

package/skills/video-craft-standards/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: video-craft-standards
+description: The definition of DONE for every video made with CueFrame — per-artifact checklists (social reel, launch film, brand reel, talking-head clip) with kill criteria. Read this BEFORE composing and score your work against it BEFORE rendering. Other skills quote this document; when a skill and this document disagree, this document wins. Triggers on "is this good enough", "quality bar", "what should a finished reel have", "review my video", or any request to make a video when no other skill has stated the bar.
+---
+
+# Video-Craft Standards — what "finished" means
+
+This is the single source of truth for output quality. A video that misses a
+MUST for its artifact class is **not done** — fix it or explicitly record why
+the rule doesn't apply. Kill criteria (**K**) mean: do not render; fix first.
+
+## Why this exists
+
+Every quality dimension nobody measures decays to the laziest default:
+template titles, silent reels, centered white text on footage. Each class
+below is the checklist a good human editor carries implicitly. Score against
+it with stills (`preview_frame`) and the judge (`score_composition`) before
+your one final render.
+
+## The controlling idea — the rule above every rule
+
+- **MUST (K)** Before composing, write the video's CLAIM in one sentence —
+  the thing a viewer should be able to repeat afterward ("real bread takes
+  48 hours and you can taste every one of them"). Not a vibe, not a tagline:
+  a claim with tension (what does this brand/story believe that its category
+  doesn't?).
+- **MUST (K)** Every channel is EVIDENCE for the claim, in harmony:
+  - **Footage** — each clip earns its place as proof of the claim, chosen
+    from the claim's shot list, not from search-term aesthetics.
+  - **Sound** — the bed's mood and TEMPO embody the claim (a "slow" claim
+    gets a patient, sparse bed and the nerve to hold shots; an "instant"
+    claim cuts hot). Silence and pauses are rhetoric, not absence.
+  - **Pacing** — the cut rhythm IS part of the argument; it may defy
+    platform convention when the claim demands it.
+  - **Type/cards** — copy advances the argument; the tagline lands as the
+    CONCLUSION the beats have earned, never as a caption.
+- **Kill tests:** (1) beats reorderable without changing what the video
+  says; (2) any channel (bed, shot, card) that would fit a different claim
+  equally well; (3) a viewer who watched it cannot state the claim.
+
+## Cross-cutting rules (every artifact)
+
+- **MUST** Brand/text graphics are AUTHORED — `kind:"card"` HTML (your
+  typography, layout, palette-as-fields) shelled with `applyMotionPreset`,
+  or a custom component. Catalog text primitives are for utility only.
+  **K:** a brand graphic rendered from a catalog text primitive.
+- **MUST** Audio is decided, never defaulted: a music bed (curated packs via
+  `import_resource {kind:"music-pack"}`) or ambience/loops (Freesound via
+  `search_resources kind:"sfx"`), honoring the brand kit's `musicMood`;
+  cut to the beat via `materializeGrid` when the bed drives pacing — OR an
+  explicit intentional-silence decision recorded in your delivery note with
+  the reason. **K:** a render whose silence nobody chose.
+- **MUST** Footage carries the video: real footage / real UI / real data
+  ≥60% of runtime for footage-first classes. Text alone is not a video.
+- **MUST** Every stock asset's provenance is recorded (provider, id, author).
+- **MUST** Safe-area respected: no critical copy in the outer ~8% of frame.
+- **MUST** One final render per approval; iterate with previews, not renders.
+- **MUST** Delivery never ends with "done": the last message carries the
+  output link and where to find it, plus the intentional-silence note if any.
+
+## 1. Social reel — 9:16 · 8–30s
+
+- **MUST (K)** The hook lands inside 2 seconds: the strongest image, motion,
+  or claim opens the piece. No logo-first cold opens, no fade-in-from-black
+  preambles.
+- **MUST** Typography is poster-grade: composed plates/fields in the brand
+  palette, considered alignment and scale. **K:** centered white text
+  floating on footage.
+- **MUST** Pacing is cut-driven: a new visual beat at least every ~4s; static
+  holds >4s need motion inside the frame (reframe push, kenBurns, animated
+  card) or they die.
+- **MUST** Ends on a deliberate beat: tagline, logo, or CTA lockup — not a
+  clip running out.
+- **SHOULD** Cuts land on the music grid when a bed exists.
+
+## 2. Launch film / feature announcement — 16:9 · 30–90s
+
+- **MUST (K)** Payoff-first hook: the OUTCOME, not the feature name
+  ("Close the books two days faster" beats "Introducing the reconciliation
+  module"). No throat-clearing ("in this video we're going to…").
+- **MUST** Narration or a bed that builds toward the reveal; pacing tightens
+  as the payoff approaches.
+- **MUST** Real product surface: actual UI/screens/output — never mocked.
+- **MUST** End card with a single CTA.
+- **MUST** Captions present when narrated.
+
+## 3. Brand-identity reel — 9:16 · 12–20s (the showcase class)
+
+Everything in §1, plus:
+- **MUST** Three-beat arc: opening brand moment (wordmark treatment) →
+  middle craft/proof beat (the subject's world, with an editorial device —
+  numbered chapter, pull-quote, stat) → closing tagline lockup.
+- **MUST** Every graphic is bespoke to the brand: its type, its palette as
+  fields, its layout system. **K:** any layout that would look correct with
+  another brand's hex swapped in.
+- **MUST** Footage color and brand palette agree — grade toward the palette
+  or choose footage that lives in it.
+
+## 4. Talking-head clip — any aspect · 15–60s
+
+- **MUST (K)** Hook = the strongest sentence, first. Cut TO the moment;
+  never open on wind-up.
+- **MUST** Active-speaker reframe (`focus: active-speaker` / `face`) — a
+  moving camera, not a static center crop.
+- **MUST** Captions timed to the real transcript (`captions.fromTranscript`).
+  The behind-the-speaker LOOK is an overlay text layer at
+  `zPlane:"behind-subject"` where the footage allows — the caption layer
+  itself always renders in front.
+- **MUST** Dead air and false starts cut (`addExcludedRange` /
+  `cutAndRipple`).
+
+## Scoring discipline
+
+Before the final render: (1) pull stills at each beat boundary and describe
+each one to yourself BEFORE judging it; (2) walk the class checklist and list
+every MUST as pass/fail; (3) any K fails → fix, re-preview; (4) run
+`score_composition` when the budget allows and fix the worst criterion first.
+The checklist is the floor; the judge is the critic; neither substitutes for
+looking at the frames.

package/dist/analyze-6ETMHDG5.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import{D as a}from"./chunk-JHOJIRD5.js";export{a as analyzeCommand};