@autoaiai/aicut 0.1.7 → 0.1.11

package/skills/explainer-video/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: explainer-video
+description: "Explainer Video Skill: the method the original skill taught, run as an AICUT film — pages that draw any moment t, cut on tracks. Runs in AICUT: the film is film.html, a page per shot, drawn by `aicut look` and `aicut render`."
+license: MIT
+source: "Mng-dev-ai/explainer-video"
+---
+
+# Explainer Video Skill
+
+## Running it in AICUT
+
+AICUT's film is `film.html`: it cuts pages, footage, pictures and sound together on tracks. A page is a web page that
+sets `window.film = { frame(t) }` and draws that moment — no framework, no build step, no composition object, no
+`registerRoot`. Five shots are five pages cut together, not one page that changes scene, so each shot stays trimmable
+and replaceable in Studio.
+
+```sh
+npx -y @autoaiai/aicut@latest          # the manual: the format and the commands, always current
+npx -y @autoaiai/aicut@latest open .   # make this folder a film and print Studio's address
+npx -y @autoaiai/aicut@latest look     # a contact sheet of the whole film, its sound, and a determinism check
+npx -y @autoaiai/aicut@latest look 4.5 # one frame, full size — look at the PNG, not at the code
+npx -y @autoaiai/aicut@latest render   # the MP4, beside film.html
+```
+
+Run the manual before the first film: it is authoritative for the format, and this skill is about the method above it.
+
+Where the words below name another program's part, it becomes this:
+
+| elsewhere | in AICUT |
+|---|---|
+| composition, timeline, project file | `film.html`; tracks and clips inside it |
+| a scene, a sequence, a slide | a page (`pages/<name>.html`) cut onto a track |
+| `useCurrentFrame()`, `interpolate()` | `frame(t)` — the picture depends only on `t`, never on state or `Date.now()` |
+| a still, a screengrab | `aicut look <t>` |
+| `render` / `build` / `export` | `aicut render` (the person can also export from Studio) |
+| a dev server, a preview window | `aicut open` and the Studio address it prints |
+
+Hard rules that hold whatever the method says: the picture depends only on `t`; every value in the person's prompt is
+binding; look at the frames `look` writes before saying a film is done.
+
+
+End-to-end pipeline: **topic → custom HTML page (you write) → MP4**.
+
+Each video gets its own visual language designed around its topic. A CRISPR video shouldn't look like a quantum computing video shouldn't look like a supply chain video. Design something fresh every time; the skill handles the plumbing.
+
+## Pipeline
+
+```
+1. Claude writes the narration script
+2. Claude writes a complete custom HTML page (with GSAP animations)
+3. Pipeline generates voiceover via Edge TTS (free, no API key)
+4. Pipeline measures audio duration and injects it into the page
+5. Page reads window.__AUDIO_DURATION and scales scene timing
+6. Pipeline records the page playback via headless Chromium
+7. Pipeline merges the recorded video + voiceover MP3 into final MP4
+```
+
+## How Claude should invoke this skill
+
+### Step 1 — Clarify
+
+Briefly ask the user for: topic, length (60-90s default), voice (`brian` default), and any tone notes. Don't over-ask — sensible defaults are fine.
+
+### Step 2 — Write the script
+
+150–220 words for 60–90s. TTS-friendly:
+- Numbers as words ("three hundred", not "300")
+- Em dashes (—) and ellipses (...) for natural pauses
+- Short sentences; vocal variety
+- Save it to `<workdir>/script.txt`
+
+### Step 3 — Write a custom HTML page
+
+Save to `<workdir>/page.html`. The HTML must satisfy this **contract**:
+
+1. **Viewport: 1280×720.** Set html/body width/height explicitly.
+2. **Load GSAP:** `<script src="https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/gsap.min.js"></script>`
+3. **Read `window.__AUDIO_DURATION`** (seconds, float) — the pipeline injects this before the page runs. Use it to scale your animation timing so visuals stay synced to the voiceover.
+4. **Set `window.__done = true`** when your animation finishes. The pipeline waits for this flag.
+5. **No external network requests** other than the jsdelivr GSAP CDN — pipeline runs headless and won't have arbitrary network.
+
+Everything else is up to you: design language, animation style, scene structure, palette, typography, illustrations, motion. Build what fits the topic.
+
+See `examples/quantum.html` for one reference implementation. Don't copy it — design something fresh for the new topic.
+
+### Step 4 — Run the pipeline
+
+From this skill's directory:
+
+```bash
+node lib/pipeline.js \
+  --html /path/to/page.html \
+  --script /path/to/script.txt \
+  --voice brian \
+  --out /path/to/output.mp4
+```
+```
+Or with a single config JSON:
+```
+```json
+{
+  "title": "My Explainer",
+  "voice": "brian",
+  "script": "Full narration...",
+  "html": "/abs/path/to/page.html"
+}
+```
+Run with `--config /path/to/config.json --out output.mp4`.
+
+**Audio caching.** Voiceover MP3s are cached by `sha256(voice + script)` at `~/.cache/explainer-video/voice/<hash>.mp3`. Re-running with the same script + voice reuses the cached MP3 (faster startup). Iterate freely on visuals.
+
+To reuse a specific audio file (e.g. one you generated externally), pass `--audio path/to.mp3` and TTS is skipped entirely.
+```
+
+### Step 5 — Report
+
+Give the user the output path. Offer to iterate on script, voice, or visual design.
+
+## Voices
+
+Friendly names map to Azure neural voices via Edge TTS:
+
+`brian` (calm documentary) · `adam` (deep authoritative) · `rachel` (warm friendly) · `sarah` (confident modern) · `antoni` (younger energetic) · `emma` · `ryan` (British) · `sonia` (British)
+
+You can also pass any Azure neural voice ID directly (e.g. `en-GB-RyanNeural`, `en-AU-NatashaNeural`, `es-ES-ElviraNeural`).
+
+## Design tips for the HTML you write
+
+- **Match the topic's emotional register.** Quantum → cosmic, mysterious. CRISPR → biological, precise. History → editorial, restrained. Climate → urgent, grounded.
+- **Use GSAP timelines** to coordinate entrance/exit/hold for each scene.
+- **Kinetic typography** (word-by-word stagger, character splits) reads well at 1280×720.
+- **Time the animation to AUDIO_DURATION.** If you have 5 scenes, distribute proportionally to script segments — not equal slices.
+- **Avoid arbitrary stock-feel motion.** Make every animation reinforce a specific idea from the narration.
+- **Flat colors render well.** Heavy gradients/glows can flash during the headless capture.
+- **Keep CSS animations smooth** — Playwright records at ~25fps.
+
+## Gotchas
+
+- The pipeline injects `<script>window.__AUDIO_DURATION=…</script>` just before `</head>`. Make sure your page has a `</head>` tag.
+- If your animation never sets `window.__done = true`, the pipeline will timeout after `audioDur + 30s`.
+- Render time ≈ realtime (60s of video takes ~60s to record).
+
+## Source
+
+Rewritten for AICUT from [`Mng-dev-ai/explainer-video`](https://github.com/Mng-dev-ai/explainer-video)
+(MIT), SKILL.md. The method is that skill's own; the way it runs is AICUT's.

package/skills/framewright/SKILL.md

@@ -0,0 +1,324 @@
+---
+name: framewright
+description: "Build a short procedural video (10–60 s) as one self-contained HTML file where every frame is a pure function of (frame number, seed, width), then render it to MP4 with headless Chrome and ffmpeg, with a synthesized soundtrack and optional photo-to-vector portraits. Use when the user asks for an animated clip, motion graphics, an intro or outro, a video greeting, shout-out or question addressed to someone, a teaser, kinetic typography, a retro TV, risograph, terminal or blueprint style animation, a one-take film where a single line or camera journey carries the story, a drawing that becomes a living painting, a landscape with nature sounds, or wants \"a video from code\" without stock footage or video editors. Runs an interactive brief, proposes three concepts, storyboards to a beat grid, builds scene by scene with visual checks, verifies the final MP4. Runs in AICUT: the film is film.html, a page per shot, drawn by `aicut look` and `aicut render`."
+license: MIT
+source: "smwbev/framewright"
+---
+
+# Framewright
+
+## Running it in AICUT
+
+AICUT's film is `film.html`: it cuts pages, footage, pictures and sound together on tracks. A page is a web page that
+sets `window.film = { frame(t) }` and draws that moment — no framework, no build step, no composition object, no
+`registerRoot`. Five shots are five pages cut together, not one page that changes scene, so each shot stays trimmable
+and replaceable in Studio.
+
+```sh
+npx -y @autoaiai/aicut@latest          # the manual: the format and the commands, always current
+npx -y @autoaiai/aicut@latest open .   # make this folder a film and print Studio's address
+npx -y @autoaiai/aicut@latest look     # a contact sheet of the whole film, its sound, and a determinism check
+npx -y @autoaiai/aicut@latest look 4.5 # one frame, full size — look at the PNG, not at the code
+npx -y @autoaiai/aicut@latest render   # the MP4, beside film.html
+```
+
+Run the manual before the first film: it is authoritative for the format, and this skill is about the method above it.
+
+Where the words below name another program's part, it becomes this:
+
+| elsewhere | in AICUT |
+|---|---|
+| composition, timeline, project file | `film.html`; tracks and clips inside it |
+| a scene, a sequence, a slide | a page (`pages/<name>.html`) cut onto a track |
+| `useCurrentFrame()`, `interpolate()` | `frame(t)` — the picture depends only on `t`, never on state or `Date.now()` |
+| a still, a screengrab | `aicut look <t>` |
+| `render` / `build` / `export` | `aicut render` (the person can also export from Studio) |
+| a dev server, a preview window | `aicut open` and the Studio address it prints |
+
+Hard rules that hold whatever the method says: the picture depends only on `t`; every value in the person's prompt is
+binding; look at the frames `look` writes before saying a film is done.
+
+
+You are going to make a short video the way a printmaker makes a print: one HTML file with a
+canvas, a list of scenes called plates, and a frame function that draws any frame on demand
+from (frame number, seed, width). No footage, no image files, nothing from a CDN. Frames are
+rendered in headless Chrome and assembled by ffmpeg. Sound is synthesized last, to the locked
+scene lengths.
+
+Talk to the user in their language. Keep the rules below even when the user is in a hurry:
+every shortcut here costs more than it saves.
+
+`SKILL_DIR` below means the folder that contains this file (in Claude Code it is
+`${CLAUDE_SKILL_DIR}`; elsewhere it is `.agents/skills/framewright`). After step 3 the
+scripts also live in the project's own `scripts/` folder.
+
+## Non-negotiables
+
+1. A frame depends only on frame number, seed and output width. No `Math.random`, no wall
+   clock, no CSS animation, no `requestAnimationFrame` as a time source. `scripts/check.mjs`
+   proves it before every full render.
+2. No image, video, font or library files, no base64, no CDN. Polygons traced from a photo
+   by a script are data and are fine. System fonts are enough.
+3. You verify by looking at rendered frames, never by reading code and imagining. Any fix is
+   confirmed with a frame.
+4. One scene at a time. Write a plate, shoot three frames, look, fix, then the next plate.
+5. Scene lengths are multiples of the beat from the first draft. Sound comes last.
+6. Full render only after a contact sheet of the whole video looks right.
+7. Never commit `frames/`, `shots/`, `*.mp4`, `*.wav` or the user's photos.
+8. Ask before installing system packages. Never publish a real person's likeness without
+   the user confirming they have the right to use it.
+
+## Workflow at a glance
+
+| Step | What happens | Checkpoint with the user |
+|---|---|---|
+| 0 | environment check | only if something must be installed |
+| 1 | brief | questionnaire, one block |
+| 2 | concepts | three options, pick one |
+| 3 | storyboard + scaffold | one "go" |
+| 4 | scenes, one by one | contact sheet every 2–3 scenes |
+| 5 | assets (photos, logos) | preview of the traced portrait |
+| 6 | full sheet, render, build | preview MP4 |
+| 7 | sound | rebuilt MP4 |
+| 8 | delivery and variations | final |
+
+Typical wall-clock: brief and concepts 10 minutes, scaffold 10, each scene 10–20, render
+2–4 minutes per minute of 1080p video, sound 15.
+
+## Step 0. Environment
+
+```bash
+bash SKILL_DIR/scripts/doctor.sh            # report; add --json for a machine-readable summary
+bash SKILL_DIR/scripts/doctor.sh --install  # installs what is missing, asks before each step
+```
+```
+Required: Node 20+, npm, ffmpeg with libx264, Puppeteer with Chrome in the project.
+Optional: Python 3 with numpy, scipy, Pillow, only when a photo will be traced. If the doctor
+reports missing tools, tell the user what will be installed and where, get a yes, then run
+`--install` (add `--yes` when the user already agreed). Do not start step 3 with a failing doctor.
+```
+
+## Step 1. The brief
+
+Run the questionnaire from `references/questionnaire.md`. Use the harness's structured
+question tool when one exists (Claude Code: `AskUserQuestion`, up to four questions per call,
+two to four options each, put the recommended option first and mark it). Without such a tool,
+print the questions as a numbered list with lettered options and a default per question, and
+accept terse answers like `1b 2a 3c`. Always ask, in this order:
+
+1. Message: what must the viewer understand or feel, in one sentence. Names, dates, links,
+   exact phrases that must appear on screen.
+2. Where it plays and the format: 16:9, 9:16, 1:1, 4:5.
+3. Length: 10–15, 20–25, 30–40, 45–60 seconds.
+4. Tone: playful, deadpan, warm, epic, technical, dark.
+5. Style: let you propose (default) or a family from `references/styles.md`.
+6. Assets: photos, logos, screenshots. Files must be placed in the project folder; an image
+   pasted into chat cannot be saved by you. Ask about rights for real people.
+7. Sound: synthesized, none, or room for the user's track (then ask its BPM).
+8. Deliverables and quality: draft or final, extra cuts (vertical, GIF, poster frame,
+   seed variations), a cover as the first frame of the MP4 (feeds show it as the preview).
+
+If the user says "you decide", take the defaults, say which ones you took, and move on.
+
+## Step 2. Concepts
+
+Propose exactly three concepts before any code. Build them from three angles: literal (show
+the subject), metaphor (a visual system that stands for the situation: a TV test card for
+waiting, a blueprint for a plan, a terminal for a process), and genre parody (news bulletin,
+arcade attract mode, safety card, weather forecast, teletext). For each concept give: a name,
+a one-sentence logline, the visual system and palette, three to five key scenes in order, the
+ending, a sound sketch, why it fits, and its main risk. Present a compact table, recommend
+one, and ask the user to pick. The method and worked examples are in
+`references/questionnaire.md`. A concept whose logline is one journey without cuts (a line that
+never lifts, a flight from a detail out to a landscape) is built as one continuous world
+(`references/world.md`); say so in its row, because it changes how scenes are built and changed.
+A concept that is one view drawn, painted and brought to life (a pencil drawing that becomes a
+living oil painting, styles 13–16) is built as a painting film (`references/painting.md`); say so
+in its row too: its plates are chapters of time over one painting, and the scene is the work.
+
+## Step 3. Storyboard and scaffold
+
+Fill `storyboard.md` (template in `assets/storyboard.md`): one row per plate, lengths in
+bars, the beat grid (30 fps, 120 BPM: beat 15 frames, bar 60), the second of the main event,
+the total. The total must equal the agreed length; when a scene is added later, another
+scene gives up a bar. Show the table and ask for a single go.
+
+Then scaffold:
+
+```bash
+bash SKILL_DIR/scripts/init.sh              # index.html, scripts/, audio.mjs, storyboard.md, package.json
+bash SKILL_DIR/scripts/init.sh . --world    # the same, but index.html is the one-world skeleton (no cuts)
+bash SKILL_DIR/scripts/init.sh . --painting # the painting skeleton; audio.mjs and nature.mjs make nature sound
+```
+```
+Open the PNGs with your image viewing tool and look at them. The skeleton's demo plate must
+render before you touch it. Then replace the demo plate with your first scene. In a painting film
+frame 0 is blank paper: shoot `30,82,200` (the drawing, the colour arriving, the living painting)
+instead, and replace the demo's scene block while the painting kit stays as it is.
+```
+
+## Step 4. Scenes
+
+Read `references/guide.md` once before the first scene. The essentials:
+
+- `plate('name', {len: 2*BAR}, (S, R) => { ... })`. `S.t` is progress 0..1, `S.i` the local
+  frame, `S.f` the global frame, `S.g` the 2D context in logical coordinates (short side
+  1080). `R` is a generator stable for the whole plate; `S.b` re-seeds every three frames and
+  gives a live line; `S.nz` changes every frame for noise. Seeds derive from the plate name.
+- All geometry in logical units, centred through `CX, CY`. Keep important content inside the
+  central 92 % of the frame; in 9:16 also out of the top 15 % and the bottom 20 %, where the
+  platform's buttons and captions sit.
+- Time inside a plate in beats: `Math.floor(S.i/BEAT)`, `span(S.i, a, b)`, `ease.out(...)`.
+  Never hard-code global frame numbers inside a scene. Something that carries on across cuts
+  takes another plate's time by name, `at('plate', beats)`; a moment the sound must hit goes
+  into `CUES` and is read with `cue('name')`.
+- Helpers live above the plates block, never between plates.
+- Transitions are drawn by the engine at plate edges (`cutIn`/`cutOut` flags); scenes do
+  not know about them.
+- A world film (`--world`) has no cuts. Plates are builders, `build(W, {pen, b, R})`, that
+  append to one timeline: `b(x)` is beat x of the plate, the pen continues the line from where
+  the previous plate left it, `camKey` moves one camera, `title` adds text. Read
+  `references/world.md` before the first builder.
+- A painting film (`--painting`) draws one still painting in three media. Its plates all call
+  `drawPainting(S)`; the view lives in the `SCENE` object and its layers between
+  `/* ===== scene ===== */` and `/* ===== end scene ===== */`, and the painting kit above it stays
+  as it is. Read `references/painting.md` before the first layer. Review the drawing alone first,
+  then the reveal, then life (`references/painting.md`, section 13).
+
+Per scene: write it, shoot the first frame, one in the middle, one five frames before the
+end, look, fix, look again. After every two or three scenes:
+
+```bash
+FROM=240 TO=480 node scripts/look.mjs sheet 12 480 7 shots/sheet-b.png   # one section, denser
+```
+```
+Checklist for the sheet, each item with your eyes: every cell reads as a still in 1.5
+seconds; no text is clipped; neighbouring lines and panels do not touch; two adjacent cells
+of one plate never look identical; cuts land where planned and do not eat the first frame
+of a scene; nothing important sits in the outer 8 %; colour is not muddy; thin lines do not
+crumble; the main event sits on its planned second; the last frame looks like an ending;
+no two titles share the screen in the same place. A scene that fails "1.5 seconds" gets
+redesigned, not decorated. An empty scene gets a bigger object or a closer camera, never more
+detail; a busy close-up gets its decor dimmed around the subject. In a world film also shoot
+the last frame of each plate next to the first frame of the next: nothing may jump.
+
+Send the sheet to the user at these points with two sentences of status. Do not narrate
+code.
+```
+
+## Step 5. Assets
+
+Photos become posterized polygons, never pixels:
+
+```bash
+bash scripts/portrait.sh photo.jpg --levels 0.14,0.28,0.42,0.56,0.70,0.84 --height 900
+```
+```
+Look at `shots/portrait_preview.png` and at the rendered frame. Tune levels, blur, crop and
+background threshold per `references/photo.md`. While the file is not yet in the folder, build
+the scene on the synthetic placeholder that ships in the skeleton and say so.
+```
+
+## Step 6. Full sheet, render, build
+
+```bash
+bash scripts/build.sh out.mp4                             # frames (+ track.wav) -> mp4
+```
+```
+The check renders five frames of every plate in seven orders (first frame of a new tab,
+forward, backward, shuffled, right after the previous frame, after another width, after a
+sweep over the film the way a render tab walks it) and demands identical pixels. It also scans
+the source for `Math.random`, `Date` and `performance.now`, fails when the page requests any
+file, and prints the beat grid and the expected render time. Fix every FAIL before rendering;
+`make.sh` runs the check and stops on a failure. A frame that changes with render order points at
+state that survives a frame: a pooled canvas drawn without clearing, a global a plate changes, a
+cache keyed without all its inputs.
+
+Verify from the file, not from the frames: `ffprobe` frame count equals the total from
+`look.mjs info`, duration equals frames divided by 30, and a tile made from the MP4 matches
+the sheet:
+```
+```
+Send the first MP4 to the user as soon as it exists, even with placeholders, and say what is
+a placeholder.
+```
+
+## Step 7. Sound
+
+`scripts/export-curves.mjs` writes `curves.json` from the page: plate starts, the cues, and for
+every frame in a world film the speed and screen position of the line's head, in a painting film
+the revealed shares, life, `gust` and zoom. `audio.mjs` takes its timeline from it, so it never
+drifts from the picture (a page without `RISO.curves()` needs the starts from `look.mjs info`
+copied into `T` by hand). Write one block of events per plate using the cue map in
+`references/audio.md`; hits on something the picture marks take their time from the page's cues,
+`cue('name')` (`CUES`, or `W.cues` in a world film), not from beat numbers copied out of a plate;
+in a world film give the line or the character a voice that follows the curves (`follow()`,
+`references/audio.md`, section 7). A painting or a landscape gets nature ambience instead of
+beats: wind, water, rustle and birds from `nature.mjs`, timed to the cues and to the page's `gust`
+by the `audio.mjs` that `--painting` copies from `assets/audio-nature.mjs` (`references/audio.md`,
+section 8, Nature ambience). Then:
+
+```bash
+node audio.mjs track.wav
+bash scripts/build.sh out.mp4
+```
+```
+You cannot listen, so read the waveform: no accidental silence inside active scenes, no
+scene pinned to the ceiling. Whenever a scene length changes, regenerate the track.
+```
+
+## Step 8. Delivery
+
+Deliver `out.mp4` (1920×1080, H.264, AAC, ~0.7 MB per second on noisy styles) and say how
+to rebuild: `bash scripts/make.sh [photo.jpg] [seed] [width]`. Offer, do not impose:
+another seed (a different impression of the same plates), a vertical cut
+(`AR=9:16 node scripts/render.mjs frames-v 7 1080 5`, then check a sheet with `AR=9:16`; lower
+titles sit at 70 % of the height there, `TITLE_Y`, clear of the platform's buttons; a painting film
+stretches its 16:9 scene and needs its own 9:16 layout, `references/painting.md`, section 11),
+a GIF for chats, a poster frame (`look.mjs shot <frame> 1920`), the HTML itself as a live
+preview. When the brief asks for the cover as the first frame, frame 0 must be a finished picture:
+no fade-in, the title already up, marks already drawn (`references/world.md`, section 7); shoot it
+at full size as the poster too. Remove intermediate MP4s so one result remains.
+
+## Changing things later
+
+Insert a scene: add the plate, shorten another to keep the total, export the curves and
+regenerate the track, reshoot the sheet. Seeds derive from plate names, so neighbours do not change.
+Change a text: reshoot the frames that show it, check `fit`. Swap a photo: rerun
+`portrait.sh`, reshoot the portrait scene. In a world film a retimed plate moves later plates
+in time and the pen carries its end point over: reshoot the boundary frames
+(`references/world.md`, section 9). Every change ends with a sheet and a rebuilt MP4.
+
+## Reference files
+
+- `references/questionnaire.md`: the brief, wording for both structured and plain-chat
+  modes, the concept generator with worked examples.
+- `references/styles.md`: sixteen visual systems with palettes, motion language, signature
+  objects, post-processing recipes and sound palettes.
+- `references/guide.md`: the engine, helpers, timing grid, review protocol, render and
+  encoding numbers, file layout.
+- `references/world.md`: one continuous world for films without cuts: builders, the pen and
+  its line, the keyed camera, the light layer, occlusion and dimming, spotlight, titles,
+  review and changes, sound from the picture.
+- `references/painting.md`: painting films: the scene contract, marks, the pencil drawing,
+  reveals, life, water, the camera, caches, costs, review and sound.
+- `references/audio.md`: cue map, synthesis blocks, mastering, checks, voices that follow the
+  picture, nature ambience (section 8).
+- `references/photo.md`: photo to polygons, parameters, rendering and animation of portraits.
+- `references/troubleshooting.md`: symptoms, causes, fixes, including environment traps.
+- `assets/skeleton.html`: the starting file. `assets/world.html`: the starting file of a world
+  film. `assets/painting.html`: the starting file of a painting film (the painting kit and a demo
+  scene). `assets/audio-template.mjs`: the sound toolkit. `assets/nature.mjs`: nature sound
+  blocks; `assets/audio-nature.mjs`: a soundtrack built on them. `scripts/export-curves.mjs`:
+  plate starts and per-frame curves for the sound.
+- `../../examples/ris-tv/` in the repository: a finished 40-second video with eight plates,
+  sound and a portrait pipeline, to read as a worked example.
+- `../../examples/honeybee/` in the repository: a finished 56-second film in one take, the
+  one-world method at full scale with sound driven by the line.
+- `../../examples/lake-dawn/` in the repository: a finished 15-second painting film, a mountain
+  lake at sunrise drawn in pencil, painted and brought to life, with nature sound.
+
+## Source
+
+Rewritten for AICUT from [`smwbev/framewright`](https://github.com/smwbev/framewright)
+(MIT), .agents/skills/framewright/SKILL.md. The method is that skill's own; the way it runs is AICUT's.