pengcut-kit 0.1.0__py3-none-any.whl

pengcut_kit/__init__.py

@@ -0,0 +1,4 @@
+"""pengcut-kit: the Lemo-Opuscar film engine, Thai fonts, sound effects and a Thai text check for an AI in a closed sandbox."""
+from pathlib import Path
+
+PAYLOAD = Path(__file__).resolve().parent / "payload"

pengcut_kit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

pengcut_kit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pengcut_kit/cli.py

@@ -0,0 +1,49 @@
+"""pengcut-kit (PyPI). The kit's tools are node scripts in payload/; this module only dispatches to them.
+
+    pengcut-kit setup [--dir ~/pengcut-kit]    copy the kit, install fonts and the engine's packages, check Thai text
+    pengcut-kit thai-check [--path all] [--image my.png] [--font sarabun-regular]
+    pengcut-kit sounds list | find <word> | path <id>
+    pengcut-kit pieces find <word> | list
+    pengcut-kit mix events.json out.wav
+    pengcut-kit path                           where the kit's files are
+
+Without node (rare: every machine that can render a library film has it), `setup` only copies the files.
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+PAYLOAD = Path(__file__).resolve().parent / "payload"
+TOOLS = {"setup": "tools/setup.mjs", "thai-check": "thai-check/thai-check.mjs", "sounds": "tools/sounds.mjs", "pieces": "tools/pieces.mjs", "mix": "tools/mix.mjs"}
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    cmd, rest = (argv[0], argv[1:]) if argv else (None, [])
+    if cmd == "path":
+        print(PAYLOAD)
+        return 0
+    if cmd in ("version", "--version"):
+        print(json.loads((PAYLOAD / "kit.json").read_text(encoding="utf-8"))["version"])
+        return 0
+    if cmd in TOOLS:
+        node = shutil.which("node") or shutil.which("nodejs")
+        if node:
+            return subprocess.call([node, str(PAYLOAD / TOOLS[cmd])] + rest)
+        if cmd == "setup":
+            target = Path(rest[rest.index("--dir") + 1] if "--dir" in rest else os.environ.get("PENGCUT_KIT_HOME", Path.home() / "pengcut-kit")).expanduser()
+            shutil.copytree(PAYLOAD, target, dirs_exist_ok=True)
+            print(f"copied the kit to {target}; no node on this machine, so the film engine and the checks cannot run here", file=sys.stderr)
+            return 1
+        print("this command needs node (Node.js 18 or newer)", file=sys.stderr)
+        return 2
+    print((PAYLOAD / "README.md").read_text(encoding="utf-8").split("\n## ")[0])
+    print("Commands: setup, thai-check, sounds, pieces, mix, path, version")
+    return 2 if cmd else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pengcut_kit/payload/NOTICE.md

@@ -0,0 +1,10 @@
+# pengcut-kit 0.1.0: what is inside and under which licence
+
+pengcut-kit is made by Pengcut (https://pengcut.furredco.workers.dev). It bundles these works unchanged, each under its own licence:
+
+- `opuscar/`: Lemo-Opuscar by LemoLab (https://github.com/lemomo-ai/lemo-opuscar, commit bebbbe1aa92a3cb4bb6f83500e61b23a17d1aa00). MIT (code and docs); demo films and stills CC BY 4.0, credit LemoLab. The MIT notice is `opuscar/LICENSE`. Left out to keep the package small: .github/, .claude-plugin/, plugin/, docs/, styleboard/, styles/*/poster.jpg, styles/*/demo/stills/, README.zh-CN.md, MAINTAINING.md, requirements-dev.txt. Films you make with it are yours; showing the library's own demo films or stills needs the credit "LemoLab" with a link to the library. Three demo voice tracks may never be reused: Game Show Flat, Paper-cut Lightbox and Broadcast News Package (they are not in this package). One line is changed by Pengcut: in `core/render/mux.sh` the decoded length of the audio is counted by a plain decode, because the original count under-reports on ffmpeg 6.1 (the line is marked "Pengcut patch").
+- `opuscar/core/fonts/thai/`: 19 Thai font files from Google Fonts (https://github.com/google/fonts, commit 5bb28733cec313b63fbd415b574b5ae35c8aa8b8), SIL Open Font License 1.1; each family's licence is in `opuscar/core/fonts/thai/licences/`. Families: Sarabun, Kanit, Mali, Noto Sans Thai, Prompt, IBM Plex Sans Thai, Chakra Petch, Mitr, Noto Serif Thai, Itim, Pridi.
+- `opuscar/demo-assets.json`: fonts (Google Fonts, OFL, Apache or UFL as listed per file) and Poly Haven HDRIs (CC0) that the library's demos load but keep out of git, added by Pengcut from those sources.
+- `pieces/`: Pengcut's library pieces, the same ones the Pengcut site offers free ("คลัง element ใช้ฟรี").
+- `sounds/`: 83 sound effects, CC0; the source of each is in `sounds/sounds.json` and `sounds/CREDITS.md`.
+- `thai-check/`, `tools/`, `starter/`, `README.md`: Pengcut, MIT License, Copyright (c) 2026 Pengcut.

pengcut_kit/payload/README.md

@@ -0,0 +1,52 @@
+# pengcut-kit
+
+Everything an AI needs to build a short film with Thai text when its sandbox cannot reach GitHub or the Pengcut site, only npm or PyPI (claude.ai chat; Claude Code cloud at Trusted). Made for Pengcut users (https://pengcut.furredco.workers.dev): Pengcut plans the clip with you through its MCP tools; this kit lets your machine build it. It holds:
+
+- the **Lemo-Opuscar film engine and style library** (MIT, by LemoLab): every film style of the library (the count is `styles` in `kit.json`), each with its recipe (`opuscar/styles/<id>/STYLE.md`) and its demo source, the fonts and HDRIs its demos load (`opuscar/demo-assets.json`), and the shared render tools;
+- **19 Thai font files** (OFL): Sarabun, Kanit, Mali, Noto Sans Thai, Noto Serif Thai, Prompt, IBM Plex Sans Thai, Chakra Petch, Mitr, Itim, Pridi;
+- **Pengcut's library pieces**: pictures with real transparency and short animations, with Thai names and tags (`node tools/pieces.mjs find ลูกศร`);
+- **the most-used sound effects** (CC0), each with its source record: `node tools/sounds.mjs list` shows what this pack holds and what it lacks;
+- **the Thai text check**: it tells you which way of drawing text on this machine puts every Thai vowel and tone mark in place;
+- a **starter film** that draws Thai whole on the engine.
+
+## Install
+
+One of these, whichever registry your sandbox reaches:
+
+```bash
+npx -y pengcut-kit setup          # npm
+pip install pengcut-kit && pengcut-kit setup      # PyPI (python -m pengcut_kit setup also works)
+```
+
+`setup` copies the kit to `~/pengcut-kit` (or `--dir`), installs the Thai fonts for this user, finds Chrome, installs the engine's npm packages (from npm) and Python packages (from PyPI), and runs the Thai check. It prints what works and the fix for what does not, and writes `setup.json`. Then, before any render: `. ~/pengcut-kit/kit.env` (sets `PLAYWRIGHT_CHROME` so the engine uses the machine's Chrome; nothing is downloaded from Playwright's servers).
+
+## Thai text: three rules
+
+1. **Run the check first and use only a path that passed.** `node ~/pengcut-kit/thai-check/thai-check.mjs` tries Chrome canvas, Pillow and ffmpeg drawtext with the test line "ที่นี่ก็ได้" and compares each with a reference picture. FAIL means upper vowels or tone marks land out of place on that path (the usual fault: the mai ek tone mark drawn into the sara ii vowel; measured 9 Nov 2026 with ffmpeg 6.1 drawtext, the version in claude.ai chat, and with Pillow without raqm; Chrome canvas and the kit's Pillow with raqm passed). Your own path: render the spec (`--spec` prints it) and pass `--image yours.png`. Look at the `-diff.png` it writes when something fails.
+2. **Use the kit's fonts**, never a font without Thai glyphs: in a page `<link rel="stylesheet" href="/core/fonts/thai/thai.css">` then `font-family: 'Kanit'` (families and weights in `opuscar/core/fonts/thai/fonts.json`); by file path for Pillow or ffmpeg.
+3. **Animate whole clusters.** A typewriter or per-letter reveal must step by grapheme cluster (`new Intl.Segmenter('th', {granularity: 'grapheme'})`), or a tone mark appears alone on screen.
+
+## Build a film
+
+The engine's guides, in order: `opuscar/AGENTS.md` (workflow), `opuscar/DIRECTOR.md`, `opuscar/TECHNIQUE.md`, `opuscar/core/README.md` (every command). A film is a folder with an `index.html` that follows the page contract (`window.READY`, `window.render(t)`, `window.DUR`, optional `window.EV`, `window.TEXTS`). Start from `starter/thai-title/`, and build the chosen style from its recipe (`opuscar/styles/<id>/STYLE.md`); read the style's demo source for technique. The library keeps its demos' fonts and HDRIs out of git and fetches them from GitHub, which a closed sandbox cannot reach; the kit adds them from their open sources (`opuscar/demo-assets.json` lists each, and any it could not find). A demo that needs a file listed as not found will not open: build that style from its recipe instead. Thai text always uses the kit's Thai fonts. Pictures: `node tools/pieces.mjs find <word>` before drawing anything in code.
+
+```bash
+. ~/pengcut-kit/kit.env
+E=~/pengcut-kit/opuscar
+cp -r ~/pengcut-kit/starter/thai-title ~/film && cd ~/film       # then edit TEXT and the look
+node $E/core/render/still.mjs ~/film 1 3 5 --size 1080x1920        # look at stills first
+node $E/core/render/video.mjs ~/film --size 1080x1920 --fps 24 --out ~/film/out/video.mp4
+node $E/core/render/events.mjs ~/film --size 1080x1920 --out ~/film/events.json
+node ~/pengcut-kit/tools/mix.mjs ~/film/events.json ~/film/out/mix.wav
+sh $E/core/render/mux.sh ~/film/out/video.mp4 ~/film/out/mix.wav ~/film/out/film.mp4
+```
+
+Vertical clips (TikTok, Reels, Shorts): `--size 1080x1920` on every command; the library's demos are 1920x1080, so a demo becomes vertical only through the style's own layout (see `opuscar/MY-STYLES.md`, field `size`).
+
+## Sounds
+
+`node ~/pengcut-kit/tools/sounds.mjs list` · `find door` (Thai works: `find ประตู`) · `path door-1`. In an event list a sound can be an id (`door-2`), a term (`door`: its first file) or a file path. A sound that is not in the pack: ask Pengcut `search_sounds` (the MCP result reaches you even when the sandbox network is closed); make it in code only as the last resort, and tell the user.
+
+## Licences
+
+`NOTICE.md`. Films you make are yours. Showing the library's own demo films or stills needs the credit "LemoLab" with a link to https://github.com/lemomo-ai/lemo-opuscar.

pengcut_kit/payload/kit.json

@@ -0,0 +1,39 @@
+{
+ "name": "pengcut-kit",
+ "version": "0.1.0",
+ "built": "2026-11-11",
+ "opuscar": "bebbbe1aa92a3cb4bb6f83500e61b23a17d1aa00",
+ "fonts_commit": "5bb28733cec313b63fbd415b574b5ae35c8aa8b8",
+ "styles": 67,
+ "fonts": [
+  "sarabun-bold",
+  "sarabun-regular",
+  "kanit-bold",
+  "kanit-regular",
+  "mali-bold",
+  "mali-regular",
+  "noto-sans-thai",
+  "prompt-bold",
+  "prompt-regular",
+  "ibm-plex-sans-thai-bold",
+  "ibm-plex-sans-thai-regular",
+  "chakra-petch-bold",
+  "chakra-petch-regular",
+  "mitr-bold",
+  "mitr-regular",
+  "noto-serif-thai",
+  "itim-regular",
+  "pridi-bold",
+  "pridi-regular"
+ ],
+ "sounds": 83,
+ "sounds_missing": [
+  "whoosh"
+ ],
+ "pieces": 714,
+ "animations": 7,
+ "demo_assets": {
+  "filled": 0,
+  "missing": 1028
+ }
+}

pengcut_kit/payload/opuscar/AGENTS.md

@@ -0,0 +1,88 @@
+# Lemo-Opuscar: instructions for agents
+
+This repository is a library of film styles. Each style has a `styles/<slug>/STYLE.md` (what the style is) and one demo film made entirely in code (`DEMO.md` and `demo/`). People pick a style and ask for a film about **their own** topic. Your job is to direct and produce that film.
+
+| The request | Go to |
+|---|---|
+| Any request: first see the user's own styles; no request yet: offer the ways in | **Start** below |
+| A film about the user's topic (the normal case) | **Style and story**, **Workflow** below |
+| "Which styles are there?" / no style chosen | **Finding the style** below |
+| Directing: story, sound, rhythm, camera, maps, checks, delivery | [`DIRECTOR.md`](DIRECTOR.md) |
+| Building: install, pages, voice, music, mix | [`TECHNIQUE.md`](TECHNIQUE.md) |
+| Tool commands and flags | [`core/README.md`](core/README.md) |
+| The user wants to change a style and keep it as their own, or make their own style from a blank page, or names a style in `~/lemo-my-styles/` | [`MY-STYLES.md`](MY-STYLES.md) |
+| Adding a style to the library (owner only) | [`MAINTAINING.md`](MAINTAINING.md) |
+
+**Films outside `styles/` are the user's: no LemoLab credit, no watermark.**
+
+## Start
+
+- **Their own styles first.** If `~/lemo-my-styles/README.md` exists, read it: it lists every style the user has saved, wherever it's kept, and their own styles ([`MY-STYLES.md`](MY-STYLES.md)) count like library styles. When they name a style, look there first, then in the library.
+- **Their language.** Talk to them in the language they write in. When they started the skill without writing anything, your first question is always the language, even when their settings, memory or earlier messages suggest one: the `AskUserQuestion` tool, a question of its own headed "Language 语言" with two options, 中文 and English (the tool adds Other, where they type any other language). Use it from then on, and as the film's default language.
+- **No request yet** (they only started the skill, or said hello): offer the ways in with one question, using the `AskUserQuestion` tool, in their language, with the first as the recommended one:
+  1. a film in a library style (**Finding the style**);
+  2. change a library style and keep it as their own ([`MY-STYLES.md`](MY-STYLES.md));
+  3. make their own style from a blank page ([`MY-STYLES.md`](MY-STYLES.md));
+  4. a film in one of their own styles, only when they have some (name them).
+
+  When their request already says which, skip the question.
+
+## Style and story
+
+- **`STYLE.md` is fixed**: the style's invariants (look, colour, type, motion, camera grammar, sound palette, native moves, pitfalls). Keep all of it.
+- **Everything else is yours to direct** from the user's topic: story, structure, characters, settings, shots, timings, references, how data is charted. Never bend the topic toward the demo.
+- **Treatment first, demo later.** Write your own `TREATMENT.md`, with three candidate structures and your choice (DIRECTOR.md §4), before you open `DEMO.md` or the demo code. Then use the demo only to learn techniques (a brush engine, a rig, a shader, a mix), never its story, arc, shots, props or timeline. One exception: a style cut from real material (Edit & Documentary) needs its material before the treatment, so the tools its `STYLE.md` names in `demo/tools/` for finding and logging material (`footage.py` and the like) may be used first, copied into the project folder and run there; still read `DEMO.md` and the rest of the demo only after the treatment is written.
+- **Scene styles** (a set-up guide, a spec walkthrough, a museum plate, a trail guide) list use cases in their `STYLE.md`. Read them as grammar for the order in which information arrives and how long each part needs on screen, then build the user's content in your own structure. Swapping text into a demo's `content.json` is only a technical check, never the way to deliver.
+- Never build inside `styles/`: copy what you need into the film's project folder.
+
+## Finding the style
+
+Users name a style by its gallery name in English or Chinese ("Impasto Oil Painting", "油画厚涂") or by its folder (`impasto`). Look it up in [`styles/README.md`](styles/README.md). If nothing matches clearly, show the closest two or three and ask.
+
+If the user hasn't picked a style:
+- Suggest two or three that fit their topic.
+- If they have their own styles, list those first, under "My styles" (in their language).
+- Show them the full list below in the chat, in the user's language only: English names (and English category names) for someone writing in English, Chinese names for someone writing in Chinese. Don't drop, merge or rename anything.
+- Link the gallery, where every style has its demo film: https://lemomo-ai.github.io/lemo-opuscar/
+- Then ask them to type the name. The list goes in your own message (a command's output isn't shown to them), and the question is plain text, not `AskUserQuestion`: its few options would hide the rest of the list.
+
+<!-- style-list:start -->
+All 66 styles · 全部风格:
+
+- **剪辑与纪实 Edit & Documentary** (8): 字幕新闻 Caption News, 1920s 新闻影片 1920s Newsreel, 实时倒计时分屏 Live Countdown Split-screen, 延时交响 Time-lapse Symphony, 视觉调查 Visual Investigation, 构成主义蒙太奇 Constructivist Montage, 体育战术板 Sports Telestrator, 电视新闻包装 Broadcast News Package
+- **实证影像 Evidence Films** (8): 卫星简报 Satellite Briefing, 工程简报板 Engineering Briefing Board, 点云测绘 LiDAR Survey, 白模投影 Projection on White Model, 数据实物化 Data Physicalization, 产品拆解 Exploded Teardown, 显微叙事 Microscope Story, 档案灯台 Archive Light Table
+- **手绘与绘画 Hand-drawn & Painting** (8): 蜡笔儿童绘本 Crayon Picture Book, 水彩笔刷 Watercolor Brush, 中国水墨 Chinese Ink Wash, 油画厚涂 Impasto Oil Painting, 一笔画 One-line Drawing, 白板讲解 Whiteboard Explainer, 钢笔淡彩 Urban Sketch · Pen & Wash, 黑板粉笔 Chalkboard
+- **东方传统 East Asian Traditions** (4): 皮影戏 Shadow Puppetry, 浮世绘 Ukiyo-e, 红色窗花剪纸 Red Paper-cut, 纸雕灯影 Paper-cut Lightbox
+- **印刷与版画 Print & Printmaking** (6): Risograph 孔版印刷 Risograph Print, 复古半调案卷 Halftone Dossier, 木刻版画 Woodcut Print, 铜版画 Copperplate Engraving, 丝印旅行海报 Silkscreen Travel Poster, 印刷长镜头 Printed Long Take
+- **图形与排版 Graphic & Type** (7): 瑞士动态排版 Swiss Motion Graphics, 60s 间谍片头 60s Spy Title Sequence, 装饰艺术 Art Deco, 蓝图 / 工程制图 Blueprint, 彩色玻璃窗 Stained Glass, 象形运动图形 Pictogram Motion, ASCII / CRT 终端 ASCII / CRT Terminal
+- **信息与发布 Information & Keynote** (8): 数据叙事 Data Storytelling, 等距信息图 Isometric Infographic, 暗色科技发布 Dark Tech Keynote, 活体实机录屏 Living Screencast, 科幻全息界面 Sci-fi Hologram HUD, 地铁线路图 Transit Map, 等距绘本 Isometric Picture Book, 电路板 Circuit Board
+- **卡通与动画 Cartoon & Anime** (4): 1930s 橡皮管卡通 1930s Rubber Hose Cartoon, 80 年代赛璐璐动画 80s Cel Anime, 科幻情景喜剧卡通 Sci-Fi Sitcom Toon, 50s 扁平卡通 Mid-century Cartoon
+- **游戏 Games** (4): 16-bit 像素 RPG 16-bit Pixel RPG, HD-2D, 微游戏快闪 Microgame Frenzy, 综艺节奏扁平 Game Show Flat
+- **电影与时代 Cinema & Eras** (2): 1920s 默片 1920s Silent Film, 后室 / 新怪谈 Liminal Found Footage
+- **材质与 3D Materials & 3D** (7): 积木玩具 Brick Toy, 纸片立体书 Paper Pop-up Book, 移轴微缩 Tilt-Shift Miniature, 低多边形等距 Low-poly Isometric Island, 玻璃质感产品 Glass Product Render, 孟菲斯微缩景观 Memphis Diorama, 桌面穿梭 Desktop Flythrough
+<!-- style-list:end -->
+
+## Workflow
+
+1. **Brief.** Make sure the style and the topic are clear, then ask the user once, in a single message (DIRECTOR.md §1):
+   - anything about the topic you can't decide yourself (facts; names, logos or products that must appear);
+   - whether they have material of their own: a voice recording or a preferred voice, music, photos, logos, fonts, and for a style built from real material, their own data or scans;
+   - the film's language, if it isn't obvious (default: the language they write in or chose, for voice and subtitles);
+   - whether they want to review a storyboard first (default: no);
+   - anything missing on their machine: first run `sh plugin/skills/lemo-opuscar/scripts/setup.sh deps` from the library root (core only) and include what it reports. Add the voice and music tiers later, only if the film needs them (TECHNIQUE.md §1).
+
+   Skip what their request already answers. Wait for the reply, fill every other gap with a sensible default, sum up the brief in a few lines and start. Don't come back with more questions.
+2. **Treatment.** Write `TREATMENT.md` in the project folder (DIRECTOR.md §4), before you open the demo (an Edit & Documentary style gathers its material first: **Treatment first** above).
+3. **Look.** Render style frames or a model sheet with the real drawing code and check them against `STYLE.md` (DIRECTOR.md §5).
+4. **Storyboard, only if the user asked for it** (DIRECTOR.md §5). **Stop and wait for approval.** Otherwise don't stop.
+5. **Produce.** Voice → check → score (can run in parallel) → animation → mix → render (TECHNIQUE.md).
+6. **Self-check and deliver** (DIRECTOR.md §11).
+
+Report progress in the user's language. If a step fails, read the error, fix the cause and retry; go back to the user only for a decision or something only they can provide.
+
+## Where things go
+
+- The film's project folder is `films/<name>/` in a clone (ignored by git), or `<name>/` in the user's folder in skill mode (see the skill's `SKILL.md`). Wherever a guide says `films/<name>/`, read "the project folder". Work only there, unless the user asks you to work in their own project.
+- Run `node core/…` and `sh tools/…` from the library root (`$LIB` in skill mode).
+- `core/` has ready-made tools (rendering, TTS, speech check, sampler, sfx, mux). Use them or your own stack, but don't edit `core/` or `styles/` for a user's film.
+- Never kill processes you didn't start. Don't leave background processes running.

pengcut_kit/payload/opuscar/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

pengcut_kit/payload/opuscar/DIRECTOR.md

@@ -0,0 +1,149 @@
+# Directing a Lemo-Opuscar film
+
+The directing method behind every film in this library. Pair it with one `styles/<slug>/STYLE.md` (the style) and [`TECHNIQUE.md`](TECHNIQUE.md) (how to build).
+
+You are the director, not a tech demo. A film is judged in this order: **sound, rhythm, camera, directing** (performance, staging, emotional arc). Good-looking frames are only the starting point.
+
+---
+
+## 1. Take the brief
+
+The user gives a style and a topic, sometimes more (length, language, voice, must-have shots, brand rules). Everything else is your decision. Ask once, in a single message (AGENTS.md, Workflow), then no more questions. Defaults:
+
+- Length **30–60 s**; shorter and tight beats padded. Beyond two or three minutes multiplies time and token cost: tell the user.
+- 1920×1080 at 24 fps by default; an output frame rate set in the style's `STYLE.md` (30 or 60 fps, for example) wins, and is what you pass to `--fps` and `mux.sh`; other sizes (vertical 1080×1920, for example) with `--size WxH` on the render tools.
+- Voice and subtitles in the language the user writes in. Subtitles burned in and exported as `.srt`.
+- Loudness −14 LUFS.
+
+Say it in the questions when it matters: a good Chinese voice uses Microsoft's online service (edge-tts) and needs a connection; offline, Kokoro reads Chinese but sounds plain (TECHNIQUE.md §4).
+
+Requests that only change the plan:
+
+- **No voice, or no subtitles.** Drop those steps and say so in the treatment.
+- **Their own voice recording.** Use it as it is; transcribe it with faster-whisper for word timings.
+- **Their own material**: logos, photos, footage, and for styles built from real material (the Evidence Films) their own data, scans, imagery or CAD. Ask whether they have any; what they give comes first, and the sources in the `STYLE.md` are the fallback. Before you download from those sources, tell the user what you will fetch, from where and under which licence. Rights: section 12.
+
+## 2. Find a benchmark first
+
+Before writing anything, pick one or two reference works (films, title sequences, games, ads) that set the bar for this style **and this topic**. They are your choice, made for the user's film; don't borrow the demo's. Write down:
+
+- **What to learn**: composition, pacing, camera grammar, colour logic, score structure.
+- **What not to take**: characters, designs, melodies, specific shots, logos, fonts.
+
+The benchmark lifts quality more than any rule below.
+
+## 3. Shape the story
+
+- **One subject, one goal, one turn.** A character (or a single object, product or idea) wants something, something changes, it ends differently from how it began.
+- **Hook in the first 3 seconds.** No slow logo reveal before anything happens.
+- **An ending that echoes.** Bookend the opening, reveal the scale, or let the character do the thing right the second time.
+- **One native move**: a moment only this medium can do (a fold that becomes a transition, ink that blooms into the next scene, a type grid that snaps into the logo). Put it at the emotional peak. `STYLE.md` lists the medium's native moves; pick or invent the one your story needs.
+- **Cut the extras.** One gag the audience reads at thumbnail size beats three they can't. If a beat needs explaining, remove it.
+
+## 4. Write the treatment
+
+Write `TREATMENT.md` before drawing anything, and before you open the style's `DEMO.md` or demo code (an Edit & Documentary style gathers its material first: AGENTS.md, "Treatment first"):
+
+1. **Three candidate structures**, a few lines each (for example: a single journey, a before/after, a countdown, a list that turns), then the one you chose and why. Choose the opening image, the ending and the shape of the score from the topic too; the first idea that comes to mind for a style is usually its cliché.
+2. **Logline and arc**: one sentence, then setup → turn → ending.
+3. **Benchmark**: learn / don't learn (section 2).
+4. **Shot list**: for every shot, the framing (wide / full / medium / close / insert), angle, camera move (push, pull, pan, track, crane, zoom), duration, and **why** it is shot that way.
+5. **Beat sheet**, second by second.
+6. **Cue map**: tempo, bar grid, instrumentation per section, and on which beat every cut, key action and subtitle lands.
+7. **Sound design table**: for each section, the ambience bed, the main foley and the music state.
+8. **Subtitle and title design**: the type is part of the style.
+
+## 5. Prove the look
+
+- **With characters**: draw a model sheet (turnaround, 3–4 expressions, 2–3 key poses, palette) plus two style frames.
+- **Without characters**: three style frames from the film, one of them the signature shot.
+
+Render them with the real drawing code, not a mock-up, and check them yourself against the `STYLE.md` before going on.
+
+### The storyboard (only if the user asked for one)
+
+Render 6–9 key shots with the real drawing code, tiled into one sheet (`core/render/sheet.py`) with shot number, framing, duration and line under each. Send it with the logline and what you are least sure about, and **wait for approval**. If the user didn't ask for one, don't stop.
+
+## 6. Sound is half the film
+
+- **Every visible action has a sound**: landings, page turns, cuts, drips, clicks, cloth. Match the material (paper, wood, metal, ink and glass all sound different).
+- **Three layers**: ambience (room, wind, rain, city), foley (tied to actions) and music. Duck the music under dialogue and key foley.
+- **At least two real silences**, or near-silences, before the turn or the emotional peak. The first sound after the silence should be one of the most important sounds in the film.
+- **Use sound as a transition** at least twice: bring the next scene's sound in early (J-cut) or let the last scene's sound run over the cut (L-cut).
+- **Avoid generic "piano and strings".** Score in the instruments of the style's sound palette.
+
+## 7. Rhythm: the music grid comes first
+
+- Write the cue map before animating. The picture locks to the grid, and a script checks every cue (TECHNIQUE.md §3).
+- **Vary the pace**: alternate fast and slow, include one clear acceleration or deceleration, and give the audience one breath (a long take or a held pause). A film at one even speed has failed.
+- One action, one sound, one cut, but don't cut on every beat. Leave time to see.
+- **Pace for the viewer, not the clock**:
+  - Hold every subtitle at least 1.8 s, and never shorter than the spoken line + 0.6 s.
+  - After text finishes animating in, hold it for roughly (letters ÷ 15 + 1.5) s in English, (characters ÷ 4.5 + 1.5) s in Chinese; `readcheck.mjs` checks this for you.
+  - Hold a title card at least 4 s.
+  - Give failures and gags enough time to be understood.
+  - Fast is fine; make it fast with fewer words per screen, not by cutting before people finish reading.
+
+## 8. Camera: every shot needs a reason
+
+- Use at least **four different camera moves** and real changes of framing. 2D has a camera too: push, pull, parallax, focus pulls, frames within frames.
+- **One signature shot** people remember: a oner, a scale reveal, a transition made from the medium itself.
+- **Design transitions inside the medium** (a page turn, a carved line growing, ink spreading), as one consistent grammar. Avoid default fades and hard cuts.
+- At key moments the subject fills at least a third of the frame height, with clear staging and a readable silhouette.
+
+## 9. Performance
+
+- **Anticipation, action, follow-through** on every meaningful move. Characters change emotion. They do not just slide across the screen.
+- **Motion continuity**, especially for characters built from code rigs:
+  - Blend every pose with keyframes and easing; never switch poses inside an `if`. The only exception is a deliberate one-frame comic pop.
+  - Check shoulders and arms on a large action test sheet (reach, raise, run, kneel) before shooting (TECHNIQUE.md §10).
+  - Held props sit **between the palms**, at a depth between the two arms. A hand-over interpolates from one palm to the other. A rolling object turns by distance ÷ radius.
+  - Step through key actions at 0.2 s intervals, enlarged.
+- Check every expression at final size, especially eyebrow direction: "worried" and "angry" are one flip apart.
+
+## 10. The failures we saw most
+
+- Subject too small, too far away, or pushed against the frame edge.
+- Too dark to read, or a colour laid on the same colour (red on red).
+- Subtitles covering the subject.
+- A gag or failure too fast to understand.
+- Blank frames in transitions.
+- A timed effect (iris, zoom, follow cam) that doesn't track the subject after the camera moves (one world → screen function, TECHNIQUE.md §2).
+
+## 11. Before you deliver
+
+- Run the review loop (TECHNIQUE.md §8): contact sheets, 0.2 s strips of key actions, one full-speed viewing with sound.
+- **One fix round.** Fix everything the review and the checks below find in one round, then check once more. Small fixes that second check turns up (a level, a frame) belong to the same round; anything bigger, tell the user in one line when you deliver. The user's notes after delivery are new rounds: change only what they ask.
+- **Not the demo again.** After the treatment, read `DEMO.md` and compare: structure, opening, signature shot, camera path, score shape, ending. At least four of the six must differ; rethink the ones that match. Before delivery, put your contact sheet next to the demo poster (`styles/<slug>/poster.jpg`) as a last check.
+- Voice: every line transcribes back correctly (speech-to-text check). For Chinese, one misheard character in a short line is normal: listen, and if it is right, let the check expect what the model heard (TECHNIQUE.md §4).
+- Loudness about −14 LUFS; no black frames, no NaN frames; subtitles in sync and not covering key action.
+- Every row of the sound design table is actually in the mix.
+- Every map, globe or satellite view passes section 13, checked enlarged.
+- No LemoLab sign-off: `grep -rniE "lemo ?lab|opus 5\.5" <project folder>` finds nothing outside `LICENSE`, `CREDITS` and the library's path in `LIB=` lines, and you have watched the last seconds of the film (text drawn into an image can't be grepped).
+
+**Deliver**, in the project folder (the complete list):
+
+- `<name>.mp4` (24 fps unless `STYLE.md` sets another rate, about −14 LUFS) and `poster.jpg`;
+- `<name>.srt`, when the film has narration, dialogue or subtitles;
+- `TREATMENT.md`;
+- `CREDITS`: every third-party asset in the film (sample libraries, music, fonts, images, the voice engine) with its source and licence (TECHNIQUE.md §11);
+- the source, with a one-command `build.sh` (TECHNIQUE.md §2).
+
+**Tell the user**, in their language: where the project folder and the film are; that `CREDITS` lists the third-party assets in the film and their licences; and that they are responsible for the materials they use in it.
+
+## 12. Copyright red lines
+
+- References teach grammar only. Don't copy characters, designs, melodies, shots, logos or type designs.
+- No existing works, games, brands or events appear in the film unless the user owns them or has the right to use them. That includes the logos, photos and footage the user hands you: use them when they say they have the right, otherwise draw fictional stand-ins.
+- Some of our demos are unofficial fan films of real events or characters. Keep the style, and never carry those names, marks or characters into a user's film.
+
+## 13. Maps
+
+These apply to every frame that shows a map, a globe or satellite imagery, in every style.
+
+- **No borders unless the film is about them.** Draw coastlines, terrain, imagery or streets, without national or provincial borders. Prefer a regional view to a world map, and keep disputed areas out of frame.
+- **When China is in frame, draw all of it.** Taiwan, Hainan, the South China Sea islands with the dashed line (in frame, or in an inset), and the Diaoyu Islands with Chiwei Yu. Taiwan and the mainland are one country, in the same colour and the same treatment. Zangnan and Aksai Chin are drawn as on China's standard map.
+- **Default border data doesn't meet this.** The default boundaries of Natural Earth, world-atlas and OpenStreetMap can't be used to draw China. When the film needs borders, use China-view data (such as Natural Earth's `admin_0_countries_chn` layers, checked against the standard map) or China's standard map service (bzdt.ch.mnr.gov.cn).
+- **Words follow the same map.** Taiwan, Hong Kong and Macao are never listed as countries: not in labels, legends, subtitles, the voice-over or data tables. A list that includes them is "countries and regions". Clean a dataset's country field before you chart it.
+- **Other disputed areas**: the same; frame them out, or leave their borders undrawn.
+- **Check and credit.** Before delivery, enlarge every map shot and check it against these rules. `CREDITS` names the map data, its source and its view (for example "Natural Earth 1:50m, China view").

pengcut_kit/payload/opuscar/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LemoLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pengcut_kit/payload/opuscar/MY-STYLES.md

@@ -0,0 +1,139 @@
+# Make a style your own
+
+A user makes a style of their own, in one of two ways: **change a library style**, or **start from a blank page**. You plan it with them, one question at a time or in free conversation, prove the look with a style frame and make a short demo film. When they confirm it, you keep it in their own folder in the same shape as a library style. From then on they name it like any library style when they ask for a film. It lives outside the library and never changes it.
+
+Use this guide when the user wants to change a style or make their own ("I want to change this style", "make my own version", "start from scratch", "我想改风格", "做成我自己的风格", "从空白开始"), or when they name a style that is in their own folder. Everything else in a film follows [`AGENTS.md`](AGENTS.md) as usual, with the exceptions this guide gives.
+
+Talk to the user in their language. Write the files in English, like the library, with the style's name in both languages.
+
+## Where it lives
+
+Until the user confirms it (§6), a style is a draft in the demo film's project folder. Confirmed styles live in **`~/lemo-my-styles/`**, outside the library, so library updates and uninstalling never touch them. `~/lemo-my-styles/README.md` lists every style, one row each (English and Chinese name, slug, base, one line on what it is, and the folder when it isn't in `~/lemo-my-styles/`): it's how a later session finds a style by name. If the user wants a style kept in another folder, keep it there and still add its row, with the full path, to `~/lemo-my-styles/README.md`.
+
+Each style has its own folder, `~/lemo-my-styles/<slug>/`, shaped like a library style (`MAINTAINING.md` **Add a style**, without the gallery and the release):
+
+| File | What it holds |
+|---|---|
+| `style.json` | `slug`, `en`, `cn`, `based_on` (the base slug; from a blank page, the technique base), `borrows` (slugs moves were taken from, may be empty), `size` (only when the default isn't 1920×1080, e.g. `"1080x1440"`), `library_version` (`git -C "$LIB" rev-parse --short HEAD`, or the plugin version when `$LIB` isn't a git clone), `created`, `line`, `line_cn` |
+| `STYLE.md` | the style's invariants only, in the sections of a library `STYLE.md` (11 in most; a changed style keeps its base's): no story, beat table, durations or end card |
+| `CHANGES.md` | one row per decision: section, base, now, why. From a blank page, "base" is the technique base's value, or "—" for something new. This is what the user approves and what you check the demo film against |
+| `DEMO.md` | how the demo film was made, like a library `DEMO.md`: it opens with "One example among many. Don't reuse its story, arc, shots, props or timings.", then the story, shots, palette, score, build notes and which file draws what. It stands in for the film's `TREATMENT.md`, which isn't kept |
+| `demo/` | the demo film's source with a one-command `build.sh` and `CREDITS`: the code and the small assets it needs to rebuild (fonts, data), not renders, frames, `node_modules`, virtual environments or caches |
+| `styleframe.jpg` | the approved style frame |
+| `styleframe-vs-base.jpg` | changing a library style only: the same frame, base on the left, theirs on the right |
+| `test.mp4`, `test.jpg` | the demo film and its poster |
+
+Never write into `styles/` or edit the library's guides for this. The name and slug must not match a library style or a row in `~/lemo-my-styles/README.md`.
+
+## 1. Where to start
+
+- **Change a library style.** The user names one (see **Finding the style** in `AGENTS.md`). If they haven't, do as **Finding the style** does for a film: the full list of library styles in your message, the gallery link, two or three suggestions on top when you know what they'll use it for, then a plain-text question asking them to type the name (not `AskUserQuestion`). One base only. If they want to mix two, take the one whose §1 *Essence* is closest as the base and take only what they want from the other, as changes (list it in `borrows`).
+- **Start from a blank page.** The user describes the look in their own words, or brings a picture or a film they like. Choose one library style as the **technique base** (the closest materials and engine: what the code will build on) and at most two to borrow moves from. Make that the first question: your choice and why in one line each, with the next closest as the other options.
+
+Either way, read the base `STYLE.md` in full before the first question. In this flow you may read the base's `DEMO.md` (and, in skill mode, get its source with `setup.sh demo <slug>`) before any treatment: the style frame needs its techniques. The demo film's story must still differ from the base demo's (DIRECTOR.md §11, *Not the demo again*, compared with the base).
+
+## 2. Plan it together
+
+Interview the user until every section of their `STYLE.md` is decided and they know what each choice costs.
+
+**How to ask**
+
+- **One question per message.** Use the `AskUserQuestion` tool: 2–3 options, the one you recommend first and marked (Recommended), each with one line on what it does to the film, and **Free conversation** (in their language) as the last option. Without the tool, a short numbered list with your recommendation, and free conversation as its last line.
+- **Free conversation.** When they pick it, stop asking one by one. Post in the chat a checklist: what's decided, and each open item with your recommendation (when changing a library style, also its group from the table below). They answer in their own words, in any order, several at once, or ask you back. When they aren't sure about an item, give two or three concrete directions for it. Update the checklist each round; when everything is decided, or they say "you decide", go to the summary.
+- Every question has your recommendation and the reason, drawn from the base `STYLE.md` and what the user said, with concrete examples from this style, not generic words.
+- Don't ask what you can look up (the base `STYLE.md`, the library, their files).
+- **About ten questions at most**, the technique base included. When more sections are in play, ask related ones together (motion with sound, camera with native moves). If they say "you decide" ("你定", "都按推荐"), take your recommendations for the rest, list them in one message and go on.
+
+**The order** (skip what they've already said):
+
+1. **Use.** What films they'll make with it, for whom, where they'll post them, and so the frame size (a vertical feed needs 1080×1920 or 1080×1440). Their brand or IP: colours, logo, font, a character. They give you the files later.
+2. **What changes.**
+   - *Change a library style*: first show the three groups as a short message, using this style's own sections and examples. Then ask which parts they want to touch (several may be picked).
+
+     Section numbers below are the usual ones; some styles (Edit & Documentary above all) number or split them differently, so go by the section's subject in the base `STYLE.md`.
+
+     | Group | Sections of `STYLE.md` | What to tell the user |
+     |---|---|---|
+     | **Safe to change** | §3 colour (the palette within its logic), §4 type, §5 motion (tempo, how much moves), §7 sound palette (instruments, density), §8 native moves (add or swap one) | the style stays itself; give 2–3 ideas for each |
+     | **Changes its character** | §2 materials and rendering, the colour logic itself in §3, §6 camera grammar | possible; say what the style loses with each change |
+     | **Can't change** | §1 essence (and its "what it is not"), §10 engine | that's a different style, not a version of this one. Say so and suggest a closer base |
+
+     When a safe change narrows a phrase in §1 (three inks become two), adjust that phrase; the essence stays.
+   - *From a blank page*: the essence first, one sentence on what it is and one on what it is not. Then the materials.
+3. **Section by section**, only the sections in play, in `STYLE.md` order: materials and rendering, colour, type, motion, camera, sound, native moves. Give 2–3 concrete directions for each.
+4. **The name**: English, Chinese or both, and the slug.
+
+**Help them change it well.** Most users know the feeling they want, not the section. While you ask:
+
+- Start from the use. The changes follow what the films are for: a weekly brand bulletin needs readable type and a fixed opening, a kids' channel needs bigger shapes and slower reading.
+- Turn vague wishes into options, never silent edits:
+
+  | They say | Usually means |
+  |---|---|
+  | more premium, 高级 | fewer colours, stronger contrast between light and dark, slower motion, more empty space, lighter type |
+  | younger, livelier, 活泼 | a brighter accent, cuts on the beat, bouncier easing, more percussion |
+  | calmer, 安静 | slower tempo, longer holds, fewer moving things, sparser instruments |
+  | like our brand, 像我们品牌 | the brand colour as the accent, not the ground; the brand font for titles; the logo at the open and the end |
+
+- **Brand.** Keep the base's light-and-dark structure so text stays readable, and bring the brand colour in as the accent first. A brand font must cover the film's language (Chinese glyphs for a Chinese film) and allow use in video. Logos and fonts come from the user.
+- **A reference.** Name two or three things in it that make it work, map each to a section, and say which ones would touch §1 essence.
+- **Keep the signature.** The native move is what makes the style recognisable: swap at most one.
+- **Changes that travel together.** Faster motion needs denser sound. A darker palette needs the type contrast checked. A new material brings its own pitfalls into §9.
+- **Up to five changes** per round when changing a library style; more are hard to judge. A change the film's language forces (a Chinese font when the base has none) doesn't count.
+- **Code draws everything**, as in the library: no image or video generation, which the user may not have. Anything that isn't code (pictures, fonts, stroke or map data, samples) is the user's own or openly licensed, as in TECHNIQUE.md §11, and named in `CREDITS`. A licence the user has to agree to is asked once, and their answer goes into `STYLE.md` so later films don't ask again. If something can't work, say so and offer the closest change code can draw.
+- **What doesn't need a style.** Story, structure, opening, ending, cast, sets, pacing and voice (§11 *Variation space*) are free in every film. If that's all they want, they don't need their own style: they say it when they ask for a film.
+
+When the plan is complete, show the user a short summary in their language: each decision, before and after, and what it costs. **Wait for their OK**, then write it down.
+
+## 3. Write it down
+
+Make the demo film's project folder now (`films/<slug>-test/` in a clone, `<slug>-test/` in the user's folder in skill mode) and work only there until §6. The draft style goes in its `style/` folder, with the files of the table above.
+
+- **`STYLE.md`**:
+  - *Change a library style*: a full copy of the base `STYLE.md` with the changes written into their sections, so it reads like any style prompt (no "see the base" gaps). Change the title to the new name and add one line under it: `Based on <base name> (<base slug>) from Lemo-Opuscar.`
+  - *From a blank page*: all 11 sections written from the plan, with §10 engine from the technique base for now (§5 points it at the style's own code). Under the title: `Made from a blank page; techniques from <base name> (<base slug>) in Lemo-Opuscar.`
+  - When the default size isn't 1920×1080, one more line under the title: `Default size: 1080×1440.`
+  - Links: the style's own `DEMO.md` and `demo/` (they exist after §5) stay relative; links to the base become `$LIB/styles/<base slug>/…`. Keep every pitfall in §9 that still applies, and add the ones the changes bring.
+- **`CHANGES.md`** and **`style.json`** as in the table above.
+
+## 4. Prove the look
+
+Render one style frame with the real drawing code, starting from the base style's techniques (copy code into the project, never edit the library). Check it against the new `STYLE.md` and fix what's off, once.
+
+- *Change a library style*: render the same frame a second time with the base's settings (its colours, materials and type; a stand-in font when the base's has no glyphs for the film's language), and put the two side by side, base on the left, so only the changes differ: `style/styleframe-vs-base.jpg` (`core/render/sheet.py` tiles stills).
+- *From a blank page*: there's nothing to compare against. Show the frame on its own, next to the user's reference if they gave one.
+
+Save the frame as `style/styleframe.jpg`. **Show it to the user and wait.** If they want more, update `STYLE.md` and `CHANGES.md` and render again. If it still isn't right after two rounds of their notes, say so and suggest a closer base.
+
+## 5. The demo film (15–30 s)
+
+A short film whose job is to show the style working, not a full production:
+
+- **Topic**: the user's own if they give one; otherwise a simple one with movement and a little light (a kite on a windy beach, the first tram of the morning). Not the base demo's story.
+- **Every row of `CHANGES.md` is clearly on screen** at least once, and the native move appears once.
+- Music and sound effects, no voice and no subtitles unless the user asks (a voice is a separate test).
+- Treatment: one structure is enough (no three candidates). No storyboard. DIRECTOR.md's counts are written for longer films: at this length one real silence and three kinds of camera move are enough.
+- **Checks**, as for any film: DIRECTOR.md §11, with its one fix round (no LemoLab sign-off in the film).
+
+Then save it into `style/`:
+
+- the film and its poster as `test.mp4` and `test.jpg`;
+- the source as `demo/`, with `CREDITS` and a `build.sh` that runs from there: `LIB=<path>` at the top, library files as `$LIB/…` (never `../..`, also in code copied from the base), and everything it writes going to `${OUT:-<a folder outside demo/>}`. Run it once from the saved folder with `OUT` set to a temporary folder, and check that `demo/` holds the same files afterwards. Code copied from the library keeps its MIT notice in `demo/CREDITS`; that is a licence, not a credit in the film;
+- `DEMO.md`;
+- From a blank page, point §10 *Engine* in `STYLE.md` at the files in `demo/` that draw the style, then at the technique base.
+
+## 6. Keep it
+
+Show the user the demo film: where it is, and each change with the second where it can be seen. Then ask with `AskUserQuestion`:
+
+1. **Keep it as my style** (Recommended): check that the name and slug are still free, copy `style/` to `~/lemo-my-styles/<slug>/` (or the folder they want), add its row to `~/lemo-my-styles/README.md` (create it if it's missing: a title and a table with one row per style), and tell them where it is and how to use it ("Make a film in my <name> style about…").
+2. **One more round**: change what they ask (§7), then ask again.
+3. **Not now**: leave it in the project folder. Tell them its path, and that saying "keep the style in <path> as my style" later saves it then.
+
+Only a kept style is theirs: listed when the skill starts, and found by name.
+
+## 7. Revise or use it
+
+- **Not right yet**: change `STYLE.md` and `CHANGES.md`, then render the style frame and the demo film again and replace `demo/` and `DEMO.md`. Change only what the user asks.
+- **Using it**: find it through `~/lemo-my-styles/README.md`. Read its `STYLE.md` in place of a library `STYLE.md` and follow the normal workflow in `AGENTS.md`, treatment first, at the style's default size unless the user asks for another. For techniques, read the style's own `DEMO.md` and `demo/` first, then the base's (`$LIB/styles/<based_on>/DEMO.md`). The demo film is one example: never reuse its story, shots or timeline. The films are the user's: no LemoLab credit, no watermark.
+- **After a library update**: if the base `STYLE.md` changed since `library_version`, mention it once and offer to bring the useful fixes into their copy. Don't change their style without asking.