@litfamily/lithermes 1.0.8 → 1.0.9

package/assets/lithermes-plugin/skills/lit-typographic-motion/references/craft-loop.md

@@ -0,0 +1,175 @@
+# Craft loop, look rounds and done
+
+Both paths share one loop: treatment, author, a stills round you look at, the
+film, a last look, then the done-check. A gate PASS alone is never done.
+
+## One loop
+
+1. **Treatment.** `treatment.md`. It is validated before every render.
+2. **Author.** Stage: `stage/index.html` (`stage.md`). Type: the brief
+   (`engine-contract.md`).
+3. **Round 1, stills.** `$M stage --out DIR --stills-only --round 1` or
+   `$M run --out DIR --stills-only --round 1`. No encode, no determinism check;
+   it writes the stills set below in seconds.
+4. **Look.** View the frames, answer the questions, record the round:
+   `$M look --out DIR --round 1 --answers FILE`. Round 1 must name the weakest
+   beat and the change you made (`change` is required). Make that change.
+5. **Film.** `$M stage --out DIR --round 2` (or `run`). This renders every frame,
+   the sound, the preview and poster, checks determinism and runs the gate.
+6. **Last look.** View the new stills set, answer again, `look --round 2`.
+   Another round is due when an answer says so (below); stop after round 3.
+7. **Done.** `$M complete --out DIR` exits 0 only when every Done rule holds.
+
+Rounds share one counter with renders: `--round N` on a render, then
+`look --round N` on the stills set that render wrote. At most three.
+
+## The stills set
+
+Every render, stills-only or full, rewrites it:
+
+- `stills/beat-NN-fF.png`: the midpoint frame of every beat (stage: the
+  treatment's beats; type: every shot);
+- `stills/strip-NN-fF.png`: one transition strip per cut, the frames 6 before,
+  at and 6 after the cut side by side;
+- `sheet/contact.png`: 12 frames spread evenly over the film;
+- `poster.png` after a full render;
+- `stills/stills.json`: the list, each file's SHA-256, the round, the mode and
+  the SHA-256 of the render's `manifest.json`.
+
+The type path also keeps `sheet/cuts.png` (four frames around every cut).
+
+## Viewing pixels
+
+Look with `vision_analyze` (the `vision` toolset), one call per PNG you name.
+Only files passed to it count as viewed. OCR output or pixel statistics may be
+recorded under `aids`; they never count as viewed. When the plugin's tool hook
+is live it records each `vision_analyze` call on a stills file; the done-check
+then requires every frame your last round lists to appear there.
+
+If no image tool is reachable in this session, record the round with
+`"blocked": "no-vision-tool"`. The done-check then ends with `DONE_UNVIEWED`,
+and the reply must say in plain words that nobody viewed the frames.
+
+## The answers file
+
+```text
+{
+  "viewed": ["stills/beat-01-f90.png", "sheet/contact.png", ...],
+  "change": "<round 1: the weakest beat and what you changed>",
+  "answers": [
+    { "q": 1, "verdict": "yes|no", "by": "blind|self", "stranger": "<the stranger's sentence, verbatim>", "frame": "sheet/contact.png", "observed": "<a concrete visible detail>" },
+    { "q": 2, "verdict": "yes|no", "frame": "stills/beat-02-f270.png", "observed": "<...>" }
+  ],
+  "aids": ["<optional OCR or statistics, never counted as viewed>"]
+}
+```
+
+`look` refuses a frame that is not in the latest stills set, and an answer
+whose `observed` is a bare yes or no: it must be at least one sentence naming a
+concrete visible detail in that frame. It stamps the round with the SHA-256 of
+the current manifest and of each listed frame. Only `look` writes `look.json`.
+
+## The questions
+
+1. "A stranger would say this film is for: <...>". Ask a fresh `delegate_task`
+   subagent that gets only the contact sheet and the beat stills, never the
+   request or the treatment. Record its sentence verbatim with `by: blind`, and
+   `verdict: yes` when it matches the treatment's subject. Without a subagent,
+   answer yourself with `by: self`.
+2. Does every beat show its `onScreen` plan?
+3. Is the craft at the level `ambition` asks for (transitions, rhythm, depth,
+   hierarchy)?
+4. Is any request text, meta label, placeholder, file name or internal term on
+   screen?
+5. Does the ending land?
+6. Does the sound follow the cuts? Answer from `sound-cues.json`.
+7. Name one thing a skilled motion designer, given only the request, would have
+   shown that this film does not (`verdict: named` or `none`). If you can name
+   one, revise.
+8. Is any element on screen without a job in its beat?
+9. Could every copy line be pasted unchanged into a film about a different
+   subject? If yes, rewrite the copy from `subject.specifics`.
+
+Another round is required after a "no" on 1, 2, 3, 5 or 6, a "yes" on 4, 8 or
+9, or a named Q7. After round 3, deliver with the open items stated plainly.
+
+## Done
+
+`$M complete --out DIR` exits 0 and writes `done.json` only when all hold:
+
+- the gate passed on the final full render;
+- `treatment.json` still validates;
+- at least 2 look rounds: round 1 on a stills-only set with a `change`, and a
+  last round on the final render;
+- the last round's manifest SHA-256 equals the final render's;
+- the last round viewed the poster, the contact sheet, every beat midpoint and
+  every transition strip of that render;
+- when the tool hook is live, each of those frames appears in a
+  `vision_analyze` call.
+
+It also compares the final treatment with the first valid one and records
+`downgraded` when `durationSec` dropped by more than 20 %, fewer beats carry a
+subject device, `sound.mode` became `none` without a user request, or `path`
+went from stage to type. A downgrade never counts as a fix; the reply names it.
+
+## Reply
+
+The activation line stays exactly where the route puts it. Below it: no second
+banner and no emoji. Plain words, no internal names (no path, preset, gate,
+beat or treatment jargon). Then:
+
+- one line on the defaults you chose;
+- a label on every invention and on a generated sound bed;
+- one plain line on what was checked: flash safety, legibility, and that the
+  frames were looked at (or that nobody could look at them);
+- where the copy lives (the `COPY` object in `stage/index.html`, or
+  `brief.json`) and the one command that re-renders;
+- any downgrade and any open look item.
+
+## Gates by path
+
+A BLOCKED exit (10, 11, 12, 14, 15) stops the loop at any round; see
+`runtime.md`. A flash failure (MO-C-03) withholds every export in `withheld/`
+on either path: say the render is withheld pending a fix.
+
+The stage gate is in `stage.md`. The type path gate follows.
+
+## Gate table
+
+Numbers marked provisional are the spec's own proposed defaults; they are
+enforced as written and labelled provisional in every report.
+
+| Rule | What fails |
+|---|---|
+| MO-C-01 | a frame with no look pass that drew |
+| MO-C-02 | a software renderer not labelled with samples lowered |
+| MO-C-03 | more than 3 general or 3 red flashes in any 1 s window of the master (non-looping) or of the exact preview frames (looping) |
+| MO-C-04 | glyph ink outside 96-1824 x 54-1026 |
+| MO-C-05 (provisional) | a non-type graphic outside 48-1872 x 27-1053 |
+| MO-C-06 (provisional size split) | body type under 4.5:1 or large type under 3:1 at a sampled settled frame |
+| MO-C-07/08 (provisional) | a unit under its reading floor, or a line over 17 characters per second |
+| MO-C-09 | a cut frame whose fresh-process re-render differs (a hardware-only mismatch that matches under SwiftShader is a warning) |
+| MO-C-10/11/12 | under 1920x1080, 30 fps or 3 s; tags other than yuv420p, bt709, tv |
+| MO-C-13 (provisional) | preview over 3 MB or poster over 1 MB (MP4 over 100 MB per 10 s only warns) |
+| MO-C-14 (provisional) | a reduced-motion still with less than 0.9x the ink of the final text frame |
+| MO-C-25 (provisional) | display tracking past -0.04 em, or negative tracking on the machine or body voice |
+| MO-C-26 | wrapped lines under the line-height floors |
+| MO-C-27 | a Latin paragraph card outside 60-75 characters |
+| MO-C-29 (provisional) | a third saturated colour cluster, or the accent in more than one timeline entry or on more than 10% of frames |
+| MO-D-02 (provisional) | frame-time p95 over 40 ms (250 ms on software GL); delivers anyway |
+| MO-D-03 (provisional) | an empty, near-black run longer than twice the scene's 2-beat floor (plus 1 s at the film's ends) |
+| MO-D-04 (provisional) | a codepoint missing from its font; this fails before any frame renders |
+
+The report then lists every other enforced engine rule (encode tags, sampling,
+seeds, event ceiling, pass caps, software downgrade, Hangul fonts and tracking,
+line breaks, stroke fonts) with PASS or FAIL.
+
+## Report format
+
+`gate-report.txt` opens with the outputs, the preset and why, duration, fps and
+resolution, the GLSL passes per shot, and the WebGL2 renderer with its launch
+flags. Then `QA gate: PASS|FAIL`, one line per rule in the order of the table
+above, the other enforced rules, the craft round (`N / 3 max`), how many frames
+`look.json` lists as viewed (a gate rerun keeps that count), the frame egress
+path, and the failed rule ids. A
+withheld render says so in the outputs line and in its last line.

package/assets/lithermes-plugin/skills/lit-typographic-motion/references/engine-contract.md

@@ -0,0 +1,166 @@
+# Scene author and engine contract
+
+The engine is a deterministic, code-driven renderer. Node builds the timeline,
+lays out type from real font outlines and composes a display list for any time
+`t`; a headless Chrome page rasterises it with WebGL2 passes and hands back the
+exact RGBA bytes; ffmpeg encodes them last. You author the brief. You do not
+write frames, pick frame numbers or call ffmpeg yourself.
+
+## The brief
+
+The type path starts from `treatment.json` like every film. `run --out DIR`
+validates it first (exit 16 names the field) and refuses a treatment whose
+`path` is `stage`. Without `--brief`, the engine brief is `DIR/brief.json`,
+written from the treatment's `copy.lines` and `durationSec` on the first run and
+then yours to refine. Its shape (placeholders; the engine refuses any `<...>`
+value, so write this film's own):
+
+```text
+{
+  "text": ["<line in film order>", "<line>", "<line>"],
+  "scenes": ["<scene id per line>"],
+  "style": "<preset id>",
+  "durationSec": <4-90>,
+  "bpm": <40-220>,
+  "seed": <integer>,
+  "accent": <line index or false>,
+  "index": <true only when the treatment asks for a shot index>,
+  "windowTitle": "<the film's own name, terminalcore only>",
+  "signalHue": "<green or blue>",
+  "audio": "<a file next to the brief>"
+}
+```
+
+Only `text` is required: the display lines in film order. Every other key is
+optional:
+
+- `scenes`: one scene id per line (below). Missing entries use the default
+  mapping: first line `title-slam`, last line `end-card`, a line with digits
+  `number-counter`, a line with three or more items split by `·`, `,`, `/`, `|`
+  or `;` `kinetic-list`, anything else `karaoke-line`.
+- `style`: a preset; it wins over the auto-pick table. The report labels it
+  `agent default` unless the user's request named that style.
+- `durationSec`: the film's length (the treatment's value when the brief has
+  none). Holds scale up until the film reaches it; they never drop below the
+  reading floor. When the floors force a longer film, the manifest warns and
+  the reply says so.
+- `bpm`: 40 to 220; default 100 (a 0.6 s beat).
+- `seed`: an integer; it drives every seeded effect.
+- `accent`: the line index that owns the one accent moment, or `false`.
+- `index`: `true` prints a shot index ("01 — 05", or "01/05" in a terminal
+  window). It is off unless the treatment asks for it.
+- `windowTitle`: the terminal window's title. Leave it out unless it is the
+  film's own name; no stock label, file name or preset id ever prints.
+- `signalHue`: `green` or `blue`, terminalcore only.
+- `mood`, `topic`: extra words the auto-pick reads.
+- `audio`: a file next to the brief. It is always muxed into the film. With a
+  pre-warmed `--audio` venv its beats also replace the fixed grid (Tier 2);
+  without one the cuts use text timing and the manifest carries the warning.
+- `wordTiming: true`: Tier 3 word alignment. It is opt-in, never implied by bare
+  `lit`, and fails closed (exit 14) until its models are pinned and installed.
+
+Each line is read in one glance only when it fits the type sizes below; a long
+line wraps to two lines on `karaoke-line`. The number of lines comes from the
+treatment's arc: one breath per supplied line.
+
+## Scenes
+
+Each scene is a pure function of the shot-local time and progress, the beat
+length and the timeline's own reveal units. Internal beats are anchored to the
+shot window and to reveal starts, never to a literal frame or second.
+
+| Scene id | What it does | Notes |
+|---|---|---|
+| `title-slam` | One large display line lands with the preset's entrance; a hairline rule draws under it | swiss steps Latin width 125 to 100 mid-landing; Hangul never |
+| `karaoke-line` | The line is laid out once, each 어절 or word appears on its reveal step; the newest word takes the signal colour | pieces are placed by glyph position inside the whole line, so kerning pairs survive the split |
+| `kinetic-list` | Items stack with index numbers in the machine voice; each enters on its reveal step | the block uses line height 1.6 |
+| `number-counter` | Counts to the first number in the line (commas, decimals and a trailing `%` kept) with a critically damped spring; the rest of the line is the label | the only stateful scene; it integrates on a fixed 1/60 s grid from the shot start and snaps to the exact value |
+| `stroke-signature` | Writes a Latin line with a single-stroke EMS font as a moving pen, timed from the shot's own window | Latin only; a Hangul line falls back to `title-slam` with a warning |
+| `end-card` | The last line settles and holds; the reduced-motion still adds the title line above it | no motion after the entrance |
+
+Terminalcore draws every scene inside a terminal window with a status bar,
+meters and a caret; text types in instead of slamming.
+
+## Timeline
+
+The timeline is built before any frame (Tier 1 by default):
+
+1. Each line's hold is `max(1.25 x reading floor, characters / 17 + 1 frame,
+   2 beats)`; karaoke and list lines also cover every reveal step plus one beat.
+2. The line's end is snapped forward to the next beat; the next line starts
+   there. Cuts are frame-aligned and within one frame of their beat.
+3. Reveal steps sit on a quarter-beat grid, at least three quarters long
+   (0.45 s at 100 BPM), never splitting a 어절.
+4. With a `durationSec` target, every hold is multiplied by one common factor
+   (found by bisection) until the last cut lands on the first beat at or past
+   the target; reveal steps and floors are never cut.
+5. A film shorter than 3 s is extended to the next beat past 3 s.
+
+The manifest's `timeline` array is the ground truth the gate checks: `id`,
+`sceneId`, `shotIndex`, `start`, `end`, `holdSec`, `kind` (`line` or `reveal`),
+`text` (after typographic punctuation), `script` and `beatSec`.
+
+## Frame, sampling and post
+
+- A frame is a pure function of `t` and the run's fixed parameters. No clock,
+  `Math.random` or network state reaches pixels.
+- The master renders 4 sub-samples per frame over half a frame of shutter:
+  `t = max(0, n/60 + (0.5/60) x ((i + 0.5)/4 - 0.5))`; the average is taken in
+  linear light before the post chain, and the post chain uses sample 2's
+  overrides. Stills, sheets and perf use 1 sample. Every sample draws the frame's
+  own shot: on a cut frame the two early samples fall before the cut and render
+  the new shot at its first moment, so a hard cut never becomes a half dissolve.
+- Stateful state (the counter spring, CRT phosphor persistence) is re-derived
+  after any seek from the shot start or from the two previous frames, so a seeked
+  frame equals the sequential one byte for byte.
+- Post chain, fixed order: bloom and halation, chromatic aberration, tone
+  shoulder, film grain, vignette, flash, shake and zoom, optional invert. Grain is
+  keyed to the output frame. sRGB is applied once, in the final pass.
+- Override fields and their ranges: exposure > 0 (neutral 1), bloom 0-1 (0),
+  bloomThreshold 0-1 (0.85), bloomKnee 0-1 (0), bloomRadius 0-1 (0), halation
+  0-1 (0), ca in px at 1080p (0), grain 0-1 (0), vignette 0-1 (0), fade 0-1 (1),
+  flash 0-1 (0), shake px pair ([0, 0]), zoom > 0 (1), invert boolean (false,
+  changes only on a cut and holds 2 beats). The starter scenes never use flash or
+  invert.
+
+## Passes
+
+Every frame must be covered by at least one look pass that actually drew. The
+render log records, per frame and pass, the draw count and the uniforms set.
+
+| Pass | Seed | Hard limits |
+|---|---|---|
+| `swiss-grid` | none | guides always off in an export |
+| `dither` | once per shot (blue-noise mode only) | never reseeded inside a shot |
+| `crt` | triad grain, once per shot | flicker peak-to-peak <= 0.06; persistence only on stateful shots |
+| `glitch` | hit schedule, once per shot | <= 2 hits/s, <= 20% of the frame per hit; one hit = displace, hold 2 frames, restore |
+| `tidal-gradient` | flow origin, once per shot | <= 2 surges/s, attack and decay >= 0.1 s |
+| `terminal-ui` | cosmetic jitter only | at most 2 layers |
+
+Seeds are `fnv1a32("runSeed:sceneId:shotIndex:pass")` as an unsigned 32-bit
+integer. Across all sources a shot carries at most 2 events (glitch hits,
+surges, flash rises, invert changes, boot flicker) in any 1 s window, and no
+pass may change 25% of the frame by 0.1 luminance in one frame pair.
+
+On a software renderer (SwiftShader, llvmpipe, softpipe, lavapipe, Apple
+software renderer, Microsoft Basic Render Driver) the engine applies one
+downgrade: 1 sample, tidal octaves 3, CRT persistence off, every pass marked
+`downgraded`, and the report says so.
+
+## Type geometry
+
+Each frame line in `render.jsonl` lists `textBoxes` measured from glyph
+outlines after scene transforms and post zoom/shake: element id, text, voice,
+font file, font size, cap height, weight, fill, ink bbox, lines, line height,
+tracking, script runs and scale. The readback's alpha channel carries the glyph
+coverage mask; the engine counts its ink pixels per frame and keeps the full
+mask for the contrast-sample and cut frames under `.run/masks/`.
+
+## Outputs and layout
+
+`<out>/film.mp4`, `preview.webp` (or `.gif`), `poster.png`, `reduced-motion.png`,
+`manifest.json`, `render.jsonl`, `gate-report.txt`, `run-state.json`, `stills/`,
+`sheet/`, `.run/` (staging, masks, sampled frames, the Chrome profile while it
+runs) and `withheld/` after a flash failure only. The poster is the first shot
+settled; the reduced-motion still is the last shot settled with the title line
+added; both render with grain and random noise at 0.

package/assets/lithermes-plugin/skills/lit-typographic-motion/references/runtime.md

@@ -0,0 +1,122 @@
+# Runtime, pre-warm and BLOCKED states
+
+## What is installed, and when
+
+The skill package ships engine code, a lockfile, font pins and licence files;
+no font and no dependency is bundled. `lithermes motion-runtime install` (and
+`lithermes install`, which attempts it) fills a product cache once:
+
+- `npm ci --omit=dev --ignore-scripts` of `runtime/package-lock.json`
+  (playwright-core as the Chrome driver, ws for frame egress, opentype.js for
+  outlines, pngjs for stills), into a staging directory under an exclusive lock,
+  renamed into place when complete;
+- every font and licence file in `runtime/fonts.json`, each downloaded from its
+  pinned URL and rejected unless its sha256 matches;
+- a check that this product's PretendardGOV Regular and Bold still match their
+  recorded hashes.
+
+The cache is `${XDG_CACHE_HOME:-$HERMES_HOME/.cache}/lithermes/motion/<digest>`,
+where the digest covers the lockfile and the font pins; the installed plugin also
+finds a cache under the Hermes home it is installed in. A failed or skipped
+pre-warm never fails `lithermes install`; it prints one receipt line naming the
+command. With `--offline` the installer skips the pre-warm and says so.
+
+Renders only read the cache and write inside `--out`. Nothing in a render or a
+Hermes session runs npm, pip or a download. Run the pre-warm in a normal shell,
+outside any sandboxed session, with the same `HOME`, `HERMES_HOME` and
+`XDG_CACHE_HOME` the session will use.
+
+## Status (five probes)
+
+`lithermes motion-runtime status` and `lithermes doctor` report, every time:
+
+1. **Chrome**: the executable and version, or not found (set `CHROME_PATH`).
+2. **ffmpeg**: the version line and the preview encoder rung available
+   (`libwebp_anim`, else `img2webp`, else GIF).
+3. **WebGL2 renderer**: the `UNMASKED_RENDERER_WEBGL` string from a real headless
+   probe, with the flag rung that produced it.
+4. **Software GL**: none, a warning naming the software renderer (renders are
+   slower and use 1 sample), or a distinct warning when the renderer string is
+   unavailable.
+5. **Pre-warm**: READY with the cache path, or exactly which dependencies and
+   fonts are missing or hash-mismatched and the command that fixes them; plus
+   the state of the optional audio venv.
+
+## Chrome launch
+
+The render tries, in order, the platform GPU rung (macOS
+`--use-angle=metal --enable-gpu-rasterization --ignore-gpu-blocklist`, Linux
+`--use-angle=gl ...`, Windows `--use-angle=d3d11 ...`) and then
+`--use-angle=swiftshader --enable-unsafe-swiftshader`, always with the three
+anti-throttling flags and `--use-mock-keychain --password-store=basic`, so a
+render never makes macOS ask where to store Chrome's keychain item. A rung counts only after `getContext('webgl2')` succeeds
+in the page, re-checked at every render launch. Chrome runs over the pipe
+transport, with its own sandbox on and a profile inside `<out>/.run/`, removed
+on exit. Frames leave the page over a WebSocket bound to `127.0.0.1:0`; if the
+host refuses `listen`, the engine pulls each frame's readback buffer through the
+driver instead and the report names that path.
+
+A host sandbox that forbids Chrome's own sandbox (nested process sandboxes on
+macOS fail with "sandbox initialization failed: Operation not permitted") stops
+the render with exit 10 and that line. The engine never adds `--no-sandbox`.
+
+## Exit codes
+
+| Exit | State | What to tell the user |
+|---|---|---|
+| 0 | OK | the requested mode finished |
+| 10 | BLOCKED_NO_CHROME | Chrome is missing or would not launch; quote the launcher's error line; install Chrome or set `CHROME_PATH`, or run outside the sandbox that blocks it |
+| 11 | BLOCKED_NO_WEBGL2 | Chrome runs but has no WebGL2 (or frames could not leave the page); quote the renderer or error; check GPU drivers or SwiftShader |
+| 12 | BLOCKED_NO_FFMPEG_FOR_VIDEO | ffmpeg is not on PATH; `run` still leaves stills and the cut sheet; install ffmpeg for the film |
+| 13 | GATE_FAIL_QA | the gate or the pre-flight failed; the report names the rules; fix and rerun the next round |
+| 14 | BLOCKED_DEPS_NOT_PREWARMED | the cache is not warm (or word-timing models are absent): run `lithermes motion-runtime install` outside this session |
+| 15 | BLOCKED_FONT_FETCH | a pinned font or licence is missing or its sha256 differs: rerun `lithermes motion-runtime install`; never accept or re-fetch it inside a session |
+| 2 | usage | a missing or invalid brief or flag |
+
+Pre-flight order: brief, word-timing request, dependencies (14), fonts (15),
+glyph coverage and timeline floors (13, nothing rendered), ffmpeg for `video`
+(12), Chrome (10, 11).
+
+## Audio (Tier 2)
+
+`lithermes motion-runtime install --audio` creates a Python venv in the cache
+from `runtime/requirements.lock` with
+`pip install --require-hashes --only-binary=:all:` (librosa and its pinned
+dependencies; Python 3.11 to 3.13; set `LITHERMES_MOTION_PYTHON` to choose the
+interpreter). When a brief names an `audio` file and the venv is ready and still
+matches its pins, `bin/audio.py` analyses that file once into
+`<out>/audio-grid.json` and the beats replace the fixed grid. If the venv is
+missing, drifted, or the analysis fails, the cuts use text timing and the
+manifest and report carry the warning. Either way the audio itself is always
+muxed into the MP4 (AAC 256k), padded or trimmed to the film with a 50 ms
+fade; the venv only decides the beat grid, never whether the track plays. The
+venv is never created or repaired during a render.
+
+## Sound bed
+
+The generated bed needs nothing pre-warmed: `sound.mjs` synthesizes it in pure
+code (tempo, pulse, pad chords, accents asked for by the treatment's beats),
+measures loudness per ITU-R BS.1770-4 (K-weighting, 400 ms blocks with 75 %
+overlap, −70 LUFS absolute and −10 LU relative gates) to −16 LUFS ± 2 with a
+sample peak at or under −2 dBFS, and writes a 48 kHz 16-bit stereo WAV with
+exactly `round(frames × 48000 / fps)` samples. The same treatment gives the same
+SHA-256. After the mux the gate decodes the film's audio: a stream must be
+present when sound is planned (exit 20 otherwise), within 0.1 s of the video,
+with a peak at or under −0.5 dBFS, and a generated bed may not sit under
+−50 dBFS RMS for more than 1.5 s in the first 3 s (exit 20; a warning for a
+supplied or authored track). aubio, essentia, madmom and
+MMS_FA weights are never used.
+
+## Word timing (Tier 3)
+
+Opt-in only (`--word-timing` or `"wordTiming": true`), never from bare `lit`.
+`lithermes motion-runtime install --word-timing` prints the model pins and the
+download size before doing anything. No licence-clean, Korean-capable alignment
+model with a recorded revision is pinned yet, so the install refuses and a
+render that asks for word timing exits 14 naming that command.
+
+## Diagnostics
+
+`LITHERMES_MOTION_FAULT_LISTEN=EPERM` makes the frame server refuse `listen`,
+to exercise the CDP-pull path. `--force-software` renders on the SwiftShader
+rung only, which the determinism re-check uses.