@olegkoval/agent-skills 1.60.0 → 1.62.0

package/adapters/cursor/olko-creative/skills/carousel-maker/scripts/edge/io.ts

@@ -0,0 +1,87 @@
+// Every process, browser and disk write the tool makes, kept out of the domain.
+import { spawnSync, type SpawnSyncOptions } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { H, W } from "../domain/layout.ts";
+import type { Json } from "../domain/types.ts";
+
+export function run(cmd: string, args: readonly string[], opts: SpawnSyncOptions = {}): string {
+  const r = spawnSync(cmd, args, { encoding: "utf8", maxBuffer: 1 << 26, timeout: 120_000, ...opts });
+  if (r.status !== 0) {
+    const out = String(r.stderr || r.stdout || r.error?.message || "");
+    throw new Error(`${path.basename(cmd)} ${args.slice(0, 2).join(" ")}... failed:\n${out.slice(-1500)}`);
+  }
+  return String(r.stdout ?? "");
+}
+
+export const has = (cmd: string): boolean => spawnSync(cmd, ["-version"], { stdio: "ignore" }).status === 0;
+export const readJson = (f: string): unknown => JSON.parse(fs.readFileSync(f, "utf8"));
+export const writeJson = (f: string, v: Json | object): void => fs.writeFileSync(f, JSON.stringify(v, null, 2) + "\n");
+export const mkdir = (...parts: string[]): string => {
+  const d = path.join(...parts);
+  fs.mkdirSync(d, { recursive: true });
+  return d;
+};
+export const writeNew = (f: string, text: string): boolean => {
+  if (fs.existsSync(f)) return false;
+  fs.writeFileSync(f, text);
+  return true;
+};
+
+export type Chrome = { readonly bin: string; readonly shell: boolean };
+
+const SHELL = process.platform === "win32" ? "chrome-headless-shell.exe" : "chrome-headless-shell";
+const SYSTEM: Readonly<Record<string, readonly string[]>> = {
+  darwin: ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Chromium.app/Contents/MacOS/Chromium", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"],
+  linux: ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser"],
+  win32: [
+    `${process.env["PROGRAMFILES"]}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env["PROGRAMFILES(X86)"]}\\Google\\Chrome\\Application\\chrome.exe`,
+    `${process.env["PROGRAMFILES(X86)"]}\\Microsoft\\Edge\\Application\\msedge.exe`,
+  ],
+};
+
+const dirs = (d: string): readonly string[] =>
+  fs.existsSync(d) ? fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(d, e.name)) : [];
+
+/** The headless shell shorts-animator's doctor (via HyperFrames) downloads, newest first. */
+const cachedShell = (): string | undefined =>
+  dirs(path.join(os.homedir(), ".cache/hyperframes/chrome/chrome-headless-shell"))
+    .toSorted()
+    .reverse()
+    .flatMap((v) => dirs(v).map((sub) => path.join(sub, SHELL)))
+    .find((f) => fs.existsSync(f));
+
+export function findChrome(): Chrome | undefined {
+  const env = process.env.CHROME;
+  if (env && fs.existsSync(env)) return { bin: env, shell: /headless-shell/.test(env) };
+  const sys = (SYSTEM[process.platform] ?? []).find((c) => fs.existsSync(c));
+  if (sys) return { bin: sys, shell: false };
+  const shell = cachedShell();
+  return shell ? { bin: shell, shell: true } : undefined;
+}
+
+// One short-lived browser per call: no DevTools socket to manage, and a crash costs one slide.
+const flags = (c: Chrome, height: number): readonly string[] => [
+  ...(c.shell ? [] : ["--headless"]), "--disable-gpu", "--hide-scrollbars", "--allow-file-access-from-files",
+  "--force-device-scale-factor=1", "--no-first-run", "--no-default-browser-check", `--window-size=${W},${height}`,
+];
+
+export const url = (file: string): string => pathToFileURL(path.resolve(file)).href;
+
+export const screenshot = (c: Chrome, html: string, png: string): void =>
+  void run(c.bin, [...flags(c, H), `--screenshot=${png}`, url(html)], { stdio: ["ignore", "ignore", "pipe"] });
+
+/** The DOM after load, images and fonts included (the virtual time budget waits for them). */
+export const dumpDom = (c: Chrome, html: string, height: number): string =>
+  run(c.bin, [...flags(c, height), "--virtual-time-budget=5000", "--dump-dom", url(html)]);
+
+export const sheet = (pattern: string, count: number, out: string): boolean => {
+  if (!has("ffmpeg")) return false;
+  const cols = Math.min(count, 5);
+  run("ffmpeg", ["-v", "error", "-y", "-start_number", "1", "-framerate", "1", "-i", pattern,
+    "-vf", `scale=360:-2,tile=${cols}x${Math.ceil(count / cols)}:padding=8:color=white`, "-frames:v", "1", out]);
+  return true;
+};

package/adapters/cursor/olko-creative/skills/carousel-maker/scripts/package.json

@@ -0,0 +1,4 @@
+{
+  "private": true,
+  "type": "module"
+}

package/adapters/cursor/olko-creative/skills/carousel-maker/scripts/test/domain.test.ts

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { check, fitFindings, report, type Facts } from "../domain/check.ts";
+import { contexts, esc, section } from "../domain/layout.ts";
+import { artOf, parseBrand, parseDeck } from "../domain/schema.ts";
+import type { Brand, Deck, Result } from "../domain/types.ts";
+
+const value = <T>(r: Result<T>): T => {
+  if (!r.ok) throw new Error(r.errors.join("; "));
+  return r.value;
+};
+
+const BRAND: Brand = value(parseBrand({ name: "Slow Hours", handle: "@slowhours" }));
+const RAW = {
+  title: "mornings",
+  slides: [
+    { kind: "cover", title: "Slow mornings, in 4 steps", body: "A calmer first hour.", art: "window" },
+    { kind: "point", title: "Wake with the light", body: "Open the curtains.", art: "light" },
+    { kind: "point", title: "Coffee, outside", art: "photos/mug.jpg" },
+    { kind: "cta", title: "Save this for tomorrow", follow: "Follow @slowhours" },
+  ],
+};
+const deck = (patch: object = {}): Deck => value(parseDeck({ ...RAW, ...patch }));
+const facts = (d: Deck, library = ["window", "light"], files = ["photos/mug.jpg"]): Facts => ({ deck: d, library, files });
+const msgs = (f: Facts, level: "error" | "warn"): readonly string[] => check(f).filter((x) => x.level === level).map((x) => `${x.where}: ${x.msg}`);
+
+test("parseBrand fills default colours and fonts, and rejects a bad colour", () => {
+  assert.equal(BRAND.colors.accent, "#e0783a");
+  assert.match(BRAND.fonts.head, /Georgia/);
+  assert.equal(parseBrand({ name: "x", colors: { accent: "orange" } }).ok, false);
+  assert.equal(parseBrand({}).ok, false);
+});
+
+test("artOf tells a library drawing from a file from nothing", () => {
+  assert.deepEqual(artOf("window"), { kind: "library", name: "window" });
+  assert.deepEqual(artOf("photos/mug.jpg"), { kind: "file", file: "photos/mug.jpg" });
+  assert.deepEqual(artOf(undefined), { kind: "none" });
+  assert.deepEqual(artOf(""), { kind: "none" });
+});
+
+test("parseDeck defaults the kind to point and names every slide without a title", () => {
+  assert.equal(deck({ slides: [{ title: "a" }] }).slides[0]?.kind, "point");
+  const bad = parseDeck({ slides: [{ title: "a" }, {}, { kind: "cta" }] });
+  assert.equal(bad.ok, false);
+  assert.deepEqual(bad.ok ? [] : bad.errors, ["slides[1] needs a title", "slides[2] needs a title"]);
+  assert.equal(parseDeck({ slides: [] }).ok, false);
+});
+
+test("a well-shaped deck with its art present checks clean", () => {
+  assert.equal(report(check(facts(deck()))), "check: clean");
+});
+
+test("missing library drawings and files are errors", () => {
+  const errors = msgs(facts(deck(), ["window"], []), "error");
+  assert.ok(errors.some((m) => m.startsWith("slide 2") && m.includes('no drawing "light"')));
+  assert.ok(errors.some((m) => m.startsWith("slide 3") && m.includes("no file photos/mug.jpg")));
+});
+
+test("an unknown kind is an error; a deck without a cover or cta is warned", () => {
+  const d = deck({ slides: [{ kind: "quote", title: "a b" }, { kind: "point", title: "c d" }, { kind: "point", title: "e f" }] });
+  assert.ok(msgs(facts(d), "error").some((m) => m.includes('kind "quote"')));
+  const warns = msgs(facts(d), "warn");
+  assert.ok(warns.some((m) => m.startsWith("slide 1") && m.includes("cover")));
+  assert.ok(warns.some((m) => m.startsWith("slide 3") && m.includes("cta")));
+});
+
+test("long titles and repeated pictures are warned", () => {
+  const d = deck({ slides: [
+    { kind: "cover", title: "one two three four five six seven eight nine", art: "window" },
+    { kind: "point", title: "short", art: "window" },
+    { kind: "cta", title: "save" },
+  ] });
+  const warns = msgs(facts(d), "warn");
+  assert.ok(warns.some((m) => m.includes("title is 9 words")));
+  assert.ok(warns.some((m) => m.startsWith("slide 2") && m.includes("repeats the picture of slide 1")));
+});
+
+test("fitFindings turns the browser's measurements into errors", () => {
+  const f = fitFindings([{ slide: 1, overflow: false, missingArt: false }, { slide: 2, overflow: true, missingArt: true }]);
+  assert.deepEqual(f.map((x) => x.where), ["slide 2", "slide 2"]);
+  assert.ok(f.every((x) => x.level === "error"));
+});
+
+test("points are numbered among points only, and the footer counts every slide", () => {
+  const d = deck();
+  const ctx = contexts(BRAND, d.slides, ["a.jpg", "b.jpg", "c.jpg", undefined]);
+  assert.deepEqual(ctx.map((c) => c.point), [0, 1, 2, 2]);
+  const html = ctx.map((c, i) => (d.slides[i] ? section(d.slides[i], c) : ""));
+  assert.match(html[2] ?? "", /<div class="n">02<\/div>/);
+  assert.match(html[0] ?? "", /swipe/);
+  assert.match(html[3] ?? "", /4\/4/);
+  assert.match(html[3] ?? "", /class="slide cta noart"/);
+});
+
+test("copy is escaped into the HTML", () => {
+  assert.equal(esc(`<b>"x" & y</b>`), "&lt;b&gt;&quot;x&quot; &amp; y&lt;/b&gt;");
+  const html = section({ kind: "point", title: "<script>", art: { kind: "none" } }, { brand: BRAND, n: 2, total: 3, point: 1 });
+  assert.ok(!html.includes("<script>"));
+});

package/adapters/cursor/olko-creative/skills/carousel-maker/scripts/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2023",
+    "lib": ["es2023"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "erasableSyntaxOnly": true,
+    "verbatimModuleSyntax": true,
+    "skipLibCheck": true
+  },
+  "include": ["*.ts", "domain", "edge", "test"]
+}

package/adapters/cursor/olko-creative/skills/shorts-animator/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: shorts-animator
+description: Use when someone wants a narrated, painted or hand-drawn animated short (TikTok, Reels, YouTube Shorts) from a script or topic and a look described in words. Every frame is drawn in code and GPU-painted, voiced locally, captioned and scored into an MP4; no image models or stock.
+license: MIT
+allowed-tools: Bash, Read, Write, Edit
+compatibility: Codex, Claude Code, Hermes Agent, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Needs Node 22.18+, ffmpeg and Chrome; the narrator installs Python and its voice model on first use.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - video
+    - animation
+    - shorts
+    - narration
+    - canvas
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# Shorts Animator
+
+A script and a look in, an animated short out. You write the lines and draw every shot as canvas code; the
+tool paints it on the GPU on twos, narrates it with a local Kokoro voice, captions it, scores it and
+encodes the MP4. Nothing is filmed, generated by an image model, or licensed.
+
+`SA` = `node <this skill's folder>/scripts/sa.ts`. Write the full command each time. One folder per short:
+`WORK=./<slug>-short`. First run on a machine: `SA doctor` (checks Node, ffmpeg, Chrome, sets up the voice,
+renders a 3-second test).
+
+## 1. Decide, do not interrogate
+
+Decide the lines, shots, look, voice and music yourself. Ask one question only if the subject is unclear.
+A pasted script is used word for word. A topic: write it per `references/writing.md`.
+
+| they say | look |
+|---|---|
+| oil, painterly, Van Gogh, swirly, "like the faith shorts" | `oil` |
+| watercolour, soft, dreamy, children's book | `watercolor` |
+| crayon, pastel, chalk, for kids | `pastel` |
+| ink, comic, graphic novel, line art | `ink` |
+| flat, storybook, gouache, poster, calm | `gouache` |
+
+Custom look: `"look": { "base": "oil", "brush": 16, "palette": {...} }`. Read `references/looks.md` only
+when overriding numbers. Voice `bm_george` (default, scripture and quotes), `am_michael`, `bf_emma`
+(stories), `af_heart` (kids); `speed` 0.85 to 0.95 reads calm. Their recording: `"voice": { "file":
+"assets/voice.m4a" }` with `say` lines matching it in order. `"voice": "none"` for music only. Music
+`mood`: `tender`, `hopeful`, `night`, `wonder`, `playful`, `none`, or a track path. `SA looks` lists all.
+
+## 2. Write the plan and the drawings
+
+```bash
+SA new "$WORK" --look oil      # short.json + scenes.js + assets/
+```
+
+`short.json` lines: `{ "say": "...", "scene": "meadow" | ["a", "b"], "move": "push", "hold": 0.8 }`.
+- A list of scenes cuts on the caption chunks. Cut often: a new picture every 1.5 to 3 s.
+- `move`: push, pull, pan-left, pan-right, rise, fall, drift, still. `transition`: cut, fade, dip (rarely).
+- `caption` shows different words; `/` forces a break. `captions.style`: box, plain, none.
+- `format`: 9:16 (default), 16:9, 1:1, 4:5. `twos`: 2 (hand-drawn), 1 (smooth).
+
+`scenes.js`: `window.SCENES = { "meadow": (k) => { k.sky({...}); k.person({...}); } }`. Read
+`references/kit.md` before writing scenes. Draw like a painter:
+- Big simple shapes, strong value contrast, one subject. The paint pass adds texture; draw nothing fussy.
+- Keep faces out of the caption band (about 77% down).
+- Every shot different: place, scale, day and night, warm and cool. Match the words.
+- Small motion: `pose: "walk"`, `dx`, rain, glints. `k.t` seconds, `k.p` progress 0 to 1.
+- No helper for it (a boat, an animal)? Write a small function with `k.g`, flat shapes in the palette.
+
+## 3. Check, then look (budgeted)
+
+```bash
+SA check "$WORK"     # no browser, about a second: missing scenes, throwing scenes, unknown kit calls,
+                     # figures under the captions, line and total length
+SA frames "$WORK"    # narrates (cached), one painted frame per shot -> frames/sheet.jpg
+SA still "$WORK" 7   # one shot full size, only when the sheet shows a problem you cannot place
+```
+
+Fix every `ERROR` from `check` before spending a browser run. Then read `frames/sheet.jpg` once. Fix muddy
+or empty shots, a figure lost in its background (contrast, `rim`), look-alike shots, a red "no scene"
+frame, and every `⚠ the page said` line. **Budget: at most two frames rounds before the first render.**
+Images are the expensive part of this loop; do not reopen a sheet you have already judged.
+
+## 4. Render and deliver
+
+```bash
+SA render "$WORK"    # about a minute for 40 s -> <title>.mp4, renders/vN.mp4 (+ its short.json), qa/sheet.jpg
+```
+
+Read `qa/sheet.jpg` only if the render printed a warning or they report a problem. Tell them in two
+lines what it is (look, length, shots) and: "Tell me what to change, one sentence is enough."
+
+## 5. One-sentence changes
+
+Smallest change, `SA check`, render, show. `SA set "$WORK" voice.speed=0.85 music.mood=night` edits
+short.json (JSON values; plain text otherwise) and refuses an invalid result.
+
+| they say | change |
+|---|---|
+| more painterly, softer | `look` or its numbers (brush, swirl, wash) |
+| slower, faster | `voice.speed`, `pause` |
+| a woman's voice, American | `voice.id` |
+| no music, more emotional | `music.mood` |
+| bigger captions, no box | `captions.size` 52, `captions.style` plain |
+| for YouTube | `format` 16:9, redraw shots whose layout breaks |
+| change shot 4 | that scene function only |
+
+## When something goes wrong
+
+| symptom | fix |
+|---|---|
+| no Chrome | install Chrome, or `SA doctor` fetches a headless one |
+| "painting on the CPU" | works, about 10x slower |
+| narrator setup fails | needs Python 3.10+ or `uv`; or use `"voice": "none"` or their recording |
+| voice timing off with their recording | `say` lines must match its words, in order |

package/adapters/cursor/olko-creative/skills/shorts-animator/references/kit.md

@@ -0,0 +1,59 @@
+# The drawing kit
+
+Every scene is `(k) => { ... }`. Positions are fractions of the frame (x 0→1 left→right, y 0→1 top→bottom);
+sizes in px are for a 1920-tall frame and scale with it (`k.u`). Draw back to front: sky, far, middle, near.
+
+| in `k` | what |
+|---|---|
+| `k.g` | the 2D canvas context (camera already applied): draw anything the helpers don't cover |
+| `k.W`, `k.H`, `k.u` | frame size, and the scale (H/1920) |
+| `k.X(x)`, `k.Y(y)` | fraction → pixels |
+| `k.t`, `k.p` | seconds into the shot (on twos), progress 0→1 |
+| `k.r()` | random, the same on every drawing of the shot |
+| `k.rng(seed)`, `k.noise1(x)` | a seeded random source; smooth 1D noise |
+| `k.pal`, `k.beat` | the short's palette; this shot's beat (scene, line, move) |
+| `k.mix(a, b, t)`, `k.alpha(c, a)` | colour helpers |
+| `IMAGES.name` | an image from `assets/` (a logo, a reference), for `k.g.drawImage` |
+
+## Sky and light
+- `k.sky({ stops: [top, …, bottom], y0, y1 })`: a gradient
+- `k.clouds({ y, band, n, size, color, shade, drift, seed })`: small cumulus in a band, drifting
+- `k.sun({ x, y, r, color, glow, glowSize, glowAlpha })`: sun, moon, a bright bulb
+- `k.glow({ x, y, r, color, a })`: any soft light (windows, lanterns, a halo)
+- `k.stars({ n, y1 })`, `k.motes({ n, y0, y1, color })` (fireflies, embers), `k.rain({ n, a, slant })`
+- `k.rays({ x, y, angle, spread, n, a, width })`: god rays through trees or clouds
+- `k.haze({ y, h, color, a })`: air between planes
+
+## Land and water
+- `k.ridge({ y, amp, freq, color, top, shape, seed })`: filled ridge: `soft` hills, `peaks` mountains,
+  `pines` a conifer line, `bush` a broadleaf line, `rocky`
+- `k.ground({ y, color, far, stripes, stripe, flowers })`: the ground plane, mown stripes, flowers
+- `k.path({ x, y, near, far, color, bend })`: a road to the horizon
+- `k.water({ y0, y1, color, deep, glint, glints })`: lake or sea with moving glints
+- `k.waterfall({ x, w, y0, y1 })`
+- `k.shape({ pts: [[x,y],…], color, smooth })`: any shape: a cliff, a giant tree trunk, an island
+
+## Plants
+- `k.tree({ x, y, h, kind, crown, trunk, fruit })`: kind `round` `pine` `autumn` `bare` `palm` `column`
+- `k.trees({ n, y, h, x0, x1, kind, crown })`: a row
+- `k.foliage({ side, x, depth, y0, y1, color, light })`: leaves hanging into frame from a side
+- `k.trunks({ n, color, light, width, x0, x1 })`: inside a forest
+
+## Built things
+- `k.house({ x, y, w, h, wall, roof, window, lit, floors, aFrame })`
+- `k.city({ y, h, color, lit, litColor, density, n })`: skyline, windows lit at night
+- `k.pagoda({ x, y, h, color })`, `k.pole({ x, y, h })`, `k.lamp({ x, y, h, light })`
+- `k.block({ x0, y0, x1, y1, color, edge })`: walls, doorways, a lit edge
+- `k.heart({ x, y, s, color })`
+
+## People
+`k.person({ x, y, h, pose, facing, hair, skin, hairColor, top, bottom, shoes, robe, rim, silhouette, walk, dx, flip, build })`
+- feet at (x, y), `h` = height as a fraction of the frame (0.25 is a full figure in a landscape)
+- `pose`: `stand` `walk` `cheer` `open` `wave` `point` `reach` `pray` `hug` `sit` `kneel` `hold`
+- `facing`: `front` | `back` (faces are left blank on purpose: it's the style, and it reads at any size)
+- `hair`: `short` `long` `curly` `afro` `bun` `hood` `hat` `cap` `bald`
+- `robe: true`: a long garment (biblical, monks, a dress)
+- `silhouette: "#111"`: one colour (backlit, sunset); `rim: "#9db6f0"`: a lit outline (night)
+- `dx`: moves over the shot (0.05 = 5% of the width); `walk`: steps per second
+- `k.people([{...}, {...}])`: several `person` calls in one
+- Two people walking together read as a relationship; a tiny figure in a huge landscape reads as awe or loneliness.

package/adapters/cursor/olko-creative/skills/shorts-animator/references/looks.md

@@ -0,0 +1,32 @@
+# Looks: from words to numbers
+
+A look is a JSON object. Start from a shipped one (`"base": "oil"`) and override.
+
+| key | what it does | range |
+|---|---|---|
+| `mode` | `strokes` (paint/pastel), `wash` (watercolour/ink), `flat` | |
+| `brush` | stroke size in px at 1920 tall | 5 fine … 11 oil … 18 bold |
+| `length` | stroke length ÷ width | 2 dabs … 4.6 hatching |
+| `swirl` | strokes follow a swirl (1) or the shapes (0) | 0 … 1 |
+| `curve` | strokes bend | 0 … 1 |
+| `bristle` | streaks inside a stroke, broken dry ends | 0 … 1 |
+| `impasto` | thick paint catching light | 0 … 1 |
+| `hueJitter` `valueJitter` `satJitter` | colour variation stroke to stroke | 0 … 0.4 |
+| `respect` | big strokes stop at edges (crisper subjects) | 0 … 1 |
+| `boil` | share of strokes redrawn every drawing (the shimmer) | 0 still … 1 lively |
+| `wash` `bleed` | watercolour pooling, blooms, granulation; how far colour runs | 0 … 1 |
+| `outline` `ink` | hand-inked lines, their colour | 0 … 1 |
+| `paper` `paperColor` `grain` | canvas/paper texture, grain | 0 … 1.6 |
+| `posterize` | flat colour bands (screen print, retro) | 0 off, 4 … 8 |
+| `saturation` `contrast` `warmth` | grade | ~0.8 … 1.3 |
+| `vignette` `bloom` | dark corners, glow from lights | 0 … 0.6 |
+| `captions` | `{ style, size, y, box, color, font, case }` | |
+
+Words → moves:
+- "thicker / bolder paint" → brush +4, impasto +0.2 · "finer" → brush −3
+- "swirly / Van Gogh" → swirl 0.9, curve 1, hueJitter 0.25 · "calmer" → swirl 0.3, boil 0.2
+- "dreamy / soft" → watercolor, bleed 1 · "crisp" → respect 1, boil 0.2
+- "vintage / old film" → saturation 0.8, warmth 0.5, grain 1, vignette 0.5
+- "comic / graphic novel" → ink, posterize 6 · "screen print / retro poster" → gouache, posterize 5
+- "night is too dark" → contrast 0.95 and lighten the palette, not the look
+- "for kids" → pastel or gouache, saturation 1.1, warm palette, playful music

package/adapters/cursor/olko-creative/skills/shorts-animator/references/writing.md

@@ -0,0 +1,9 @@
+# Writing the lines
+
+- One idea per line, 4 to 12 words. Read aloud it should take 1.5 to 4 seconds.
+- Open on a hook that makes the second line necessary ("You have heard that it was said,").
+- A turn two-thirds in ("But…", "And yet…", "Nobody ever…").
+- Land the last line; give it `hold: 0.8` and a final wide or calm shot.
+- Scripture, quotes and poems: use a public-domain translation (KJV, WEB) or their own words; keep it exact.
+- Never invent a quote and attribute it to a real person.
+- 20 to 45 seconds is the sweet spot for Shorts, Reels and TikTok; 60 s at most.