@officexapp/vidfarm-devcli 0.21.53 → 0.21.54

package/experimental/wall-text-pov-ugc.md

@@ -0,0 +1,2036 @@
+---
+name: wall-text-pov-ugc
+video_type: Wall of text over an ambient POV or UGC scene — one unbroken take, one static block of unplated type, no voiceover, no cuts (TikTok / Reels / Shorts)
+checks:
+  duration_sec: 8-12        # 8s FLOOR so a trending audio overlay gets a real phrase of a
+                            # track, not a fragment. See "Length". words/8 sets it inside the band.
+  aspect: 9:16
+  first_frame_visual: required
+  first_frame_text: required
+  text_by_sec: 0            # the whole wall is up at frame 0. There is no reveal, no build
+  captions: optional        # there is NO subtitle track and no voiceover to caption. The
+                            # wall IS the text layer. A caption run here would flag every
+                            # video in the format for a defect it structurally cannot have
+  audio: required           # a flat ambient bed. See "Audio DNA" — measured, not chosen by ear
+  font_regime: required
+  safe_zone: required
+  scenes: 1-2               # one unbroken take, plus the frame-0 poster still
+  max_scene_sec: 12
+  max_text_cards: 2         # the wall, and the handle. Nothing else
+  max_simultaneous_text: 2
+  # ⚠️ THIS IS THE FORMAT. Every other harness caps this at 7-12 to stop wall-of-text.
+  # Here the wall IS the mechanic, so the cap is opened right up.
+  #
+  # There is deliberately NO MINIMUM, here or anywhere else in this file. A floor would
+  # be an instruction to pad, and padding is the format's most common fatal failure —
+  # invisible to every check in this file and instantly obvious to a reader. Short walls
+  # are allowed and are often better. Read "Density" before you touch this number.
+  max_words_per_cue: 120
+  max_dead_air_sec: 12      # the wall never leaves the screen. There is no dead air here
+  max_tail_sec: 0.3         # the text is legible on the LAST frame too — it loops
+  forbid_text:
+    - link in bio
+    - sign up
+    - free trial
+    - get started
+    - book a demo
+    - download now
+    - learn more
+    - swipe up
+    - dm me
+    # the bait is the wall's own last line and the post caption. Never a CTA card:
+    - comment below
+---
+
+# Wall Text × POV / UGC
+
+> A public Vidfarm prompt. Read it end to end before you build. Derived by measurement from
+> two reference templates — `template_019fd6b095d175578dc382aedd8c8f72` ("Night Drive
+> Confession", 5.13s) and `template_019fd6b04c1775bbbafaeaecf157df6d` ("Night Drive Text
+> Story", 5.10s), both from the same TikTok account, both catalogued under
+> **Text / Story-Driven**. Every number in this file with a decimal point in it came off
+> those two files, not off taste.
+
+The simplest format in the catalog, and the one agents get wrong fastest — because every
+instinct a video editor has is the wrong instinct here.
+
+Two ingredients. There is no third.
+
+| Ingredient | What it is | Where it comes from |
+|---|---|---|
+| 🎞 **The scene** | One unbroken ambient take. A POV the viewer looks *out of*, or a UGC scene with a person in it who is not talking to camera | Public raws (`ugc-reaction`, `lifestyle`), the customer's own footage, a phone out a car window, or a generated plate |
+| 🧱 **The wall** | 40–120 words of static, unplated type, centred on the frame, up at frame 0 and unchanged to the last frame | You. It is the only original work in the video and it is ~95% of the outcome |
+
+**No cuts. No voiceover. No subtitles. No music with a drop. No zoom, no Ken Burns, no
+animation on the text.** Every one of those is an editor doing their job, and every one of
+them destroys the format. What you are making is closer to a **screenshot that happens to
+move** than to a video.
+
+---
+
+## The one test
+
+> **Is every single line of the wall worth reading?**
+
+Not "is it long enough". **Length is an output of having something to say, and it is the one
+thing in this format that is trivially faked.** A wall padded to hit a word count is the format's
+most common and most fatal failure, because padding is invisible to every machine check in this
+file and instantly obvious to a reader — they feel the sentence that adds nothing, and they
+leave on it.
+
+So the test is per line: **cover any line and ask whether the wall got worse.** If it did not,
+that line is gone. Run it on every line, including the first.
+
+### The second test — does one play get them to the halfway mark?
+
+The retention mechanic, and the one number in this file the clip length is chosen from.
+
+> **The clip runs long enough to read HALF the wall. No more.**
+
+```
+read_time = words / 4.0     # ~4 words/sec, the fast end of phone reading
+duration  = words / 8.0     # half the read time — THIS IS THE RULE
+```
+
+`duration = words / 8`, **clamped to 8–12 seconds**. A 64-word wall gets exactly 8.0s; a 90-word
+wall gets 11.3s. **Never pick a duration by feel and never inherit one from the source clip.**
+
+The 8-second floor is not about reading. It is so a poster can drop a trending sound on the
+video in the platform's own editor and get **a recognisable phrase of a track** rather than a
+fragment. That is worth more than the second or two of ratio it costs, because trending audio is
+a distribution surface this format otherwise has no access to — it has no voiceover, no music of
+its own, and nothing else the algorithm can match on.
+
+#### Why half, and not a quarter
+
+Expressed as a ratio, `read_time / duration`, half is **2.0** — and 2.0 is the number to build
+to, not the highest number you can reach.
+
+A viewer who reaches the halfway mark of a wall has **committed**. They are mid-sentence, they
+know where they are, and one more pass finishes it — so they take it, and you bank two full
+plays with near-certainty. That is the mechanic working.
+
+Push the ratio to 4 and you have not doubled anything. The viewer now needs **four** passes,
+and on the first one they get a quarter of the way in, feel the size of what is left, and
+decide it is not worth the work. You traded a near-certain second play for an unlikely fourth,
+which is a bad trade twice over: a bail at 25% is also a much worse retention signal than a
+completed loop.
+
+**Band: 1.8–2.4** (they finish 42–56% on the first pass). Outside it, move the *clip*.
+
+| | Words | Read | Duration | Ratio | |
+|---|---|---|---|---|---|
+| Reference A — "Night Drive Confession" | 55 | 13.8s | 5.13s | 2.68 | a little past half |
+| Reference B — "Night Drive Text Story" | 83 | 20.8s | 5.10s | 4.07 | quarter-of-the-way — too far |
+
+**The references are not the model here.** A is close to right; B is the failure this rule
+exists to prevent, and it is the more-viewed of the two only because the wall is very good. At
+`words / 8` B would run 10.4s.
+
+> ⚠️ **The trap, spelled out, because the arithmetic invites it.** `ratio = words / (4 × duration)`
+> has two variables and an agent will reach for the wrong one. **Words are never the lever.**
+> There is no minimum word count and no minimum ratio in this format — a 33-word wall carrying
+> one clean observation, on a 4.1s clip, is a finished video. If the ratio is off, the clip is
+> the wrong length. Change the clip.
+
+#### The 8s floor sets the format's natural word range: 64–96
+
+`words / 8` only lands inside 8–12s when the wall is **64 to 96 words**. That is the band where
+the music floor and the 50% rule agree, and it is where most of a batch should sit.
+
+Outside it, one of the two has to give, and **it is never the wall that gives**:
+
+| Wall | What happens | Call it what it is |
+|---|---|---|
+| **64–96 words** | `words/8` lands in band. Ratio 2.00 | The sweet spot |
+| **48–63 words** | Clamps up to 8.0s. Ratio 1.3–1.9 | **A partial loop.** They get most of the way through and still need a second pass. Barely worse than the sweet spot |
+| **Under ~48 words** | Clamps up to 8.0s. At 33 words the ratio is **1.03** — 97% read in one play | **A single-read video.** The loop mechanic is gone. A legitimate choice, not a defect, but you traded it and you should know you did |
+| **Over 96 words** | Clamps to 12.0s. Ratio climbs past 2.0 | Cut the wall. This is the one case where the wall is genuinely too long |
+
+**Do not pad a short wall up to 64 words to recover the ratio.** That is the exact failure the
+density section exists to prevent, and a padded 64-word wall performs worse than a sharp 33-word
+one that only gets read once. If a short wall is the right wall, ship it and accept one play.
+
+Everything a short wall loses in loops it partly returns in legibility: at 33 words the fitter
+returns **52px**, its ceiling, against 39–41px for a 70-word wall. Bigger, bolder, read at a
+glance.
+
+`walltext-build.py` computes this for you: `--dur auto` is the default.
+
+---|---|---|---|---|
+| Reference A — "Night Drive Confession" | 55 | 13.8s | 5.13s | **2.68** |
+| Reference B — "Night Drive Text Story" | 83 | 20.8s | 5.10s | **4.07** |
+
+A 5-second video that takes 21 seconds to read banks four plays per person who commits to it,
+and the platform cannot distinguish four committed plays from four people who loved it.
+
+**Read the ratio in one direction only: it tells you how long to cut the clip.** It is not a
+target the wall has to reach.
+
+> ⚠️ **This is the trap, and it is worth spelling out because the arithmetic invites it.**
+> `loop_ratio = words / (4 × duration)` has two variables, and an agent looking to raise it will
+> reach for the wrong one every time. **Words are the numerator you must never touch.** The clip
+> length is free — cutting a 7s plate to 4.5s raises the ratio by 55% and costs nothing, and a
+> shorter clip reads as tighter besides.
+>
+> There is no minimum word count in this format, and there is no minimum ratio. A 34-word wall
+> that is one clean observation, on a 4-second clip, is a **2.1** and it is a better video than
+> a 90-word wall padded to a 4.4. Ship the short one.
+
+Above ~6.0 the mechanic does invert — the wall reads as homework, the viewer bails on the first
+pass rather than committing — so that end is a real ceiling. The bottom end is not a floor; it
+is a note that your clip could be shorter.
+
+---
+
+## Density — the wall earns every word
+
+Everything an agent knows about writing works against this format. Agents write prose: a
+run-up, a restatement, a hedge, a tidy close. **Every one of those habits is a line a reader
+abandons the video on.**
+
+Assume the first draft is **30–40% too long**, and go find the words. On the reference walls the
+poster's own contribution is almost nothing — Reference A's entire authored content, outside the
+quote, is *"I saw a tiktok saying"* and *"Is this true?"*. Eight words.
+
+### Cut on sight
+
+| Habit | Looks like | Fix |
+|---|---|---|
+| **The wind-up** | *"my girlfriend said something in the kitchen last week that i haven't stopped thinking about. she said…"* | *"my girlfriend said…"*. 15 words to 3. The claim is the hook; the run-up is throat-clearing |
+| **The permission slip** | *"i want to admit something embarrassing."* · *"this might be controversial but"* | Delete. Just say the thing. Announcing a confession is not confessing |
+| **Restatement** | The same point in two sentences with different words | Keep the sharper one |
+| **The hedge** | *"maybe"* · *"kind of"* · *"i think"* · *"sort of"* | Delete. A confession is not qualified. One hedge can be deliberate; three is a voice with no spine |
+| **The tidy close** | *"anyway"* · *"just something i've been thinking about"* · any summary of what was just said | Delete. Stop on the sharpest clause, a beat before it feels finished |
+| **The list** | Three examples where one specific one lands harder | Keep the most specific. Three abstractions do not add up to one rung-4 |
+| **Explaining the joke** | Naming the feeling the wall already produced | Delete. The reader got there |
+
+### The two-thirds test
+
+Take the finished wall and cut it to two-thirds the words without losing an idea. **If you can,
+the two-thirds version was the wall.** If you genuinely cannot, it was already dense. This takes
+four minutes and it is the highest-leverage four minutes in the build.
+
+### Short walls are allowed and often better
+
+There is no floor. What matters is that the wall carries **one real thing** — an observation
+that is specific, arguable, and true. A 34-word wall that does that beats a 90-word wall that
+says it and then keeps talking.
+
+Signals you have earned the length, rather than padded to it:
+
+- Every sentence introduces a **new** fact, turn, or escalation — none restates.
+- The wall reaches rung 3 or 4 by *naming a mechanism step by step*, which is long because the
+  mechanism has steps, not because you wrote more words.
+- Cutting any sentence removes something a reader would have wanted.
+
+If a long wall does not pass those, it is not a long wall. It is a short wall with padding.
+
+---
+
+## The second test — the cover test, both ways
+
+Two questions, and **both** must be yes:
+
+| Cover this | Ask | If no |
+|---|---|---|
+| The background | Does the wall still land as something a real person wrote? | You wrote ad copy. The scene was carrying it |
+| The wall | Is the background boring on its own? | The scene is stealing. Recast it |
+
+The second half is the one nobody believes. **The background is supposed to be boring.** It
+is not b-roll, it is not illustration, and it is not "showing" anything. Its whole job is to
+give the words a *mood* and a *place* while contributing **zero semantic content** — because
+every scrap of meaning in the frame is a scrap of attention not spent reading, and reading is
+the only thing happening in this video.
+
+A night drive works because a road at night means nothing and feels like everything. A clip
+of someone cooking does not work, no matter how pretty, because the viewer starts watching
+the cooking.
+
+---
+
+## Part 0 — who this is for
+
+**Not the customer's buyer in general — the customer's buyer at 11pm, alone, already
+thinking about this.** Before you write a word, put three lines at the top of your build log:
+
+```
+WHO:      <the person, in six words>
+MOMENT:   <where they are and what time it is when this thought arrives>
+THE ACHE: <the sentence they have never said out loud>
+```
+
+The third line is the video. Everything else is production.
+
+- **Register:** a person typing into their own phone. Not addressing an audience. Not
+  performing. The wall should read as though you are seeing something you were not quite
+  meant to see.
+- **Never a brand voice.** No "we", no "introducing", no feature words, no benefit language.
+  The offer may appear (Rule 1) but the *voice* never becomes the offer's.
+- **Lowercase is allowed and often correct.** Reference B is entirely lowercase. Reference A
+  is sentence case. Both read as typed; neither reads as designed. Pick one and hold it for
+  the whole wall.
+- **The joke, if there is one, is never on the viewer.** This format has no joke. It has a
+  recognition, which is a different and more dangerous thing to get wrong.
+
+---
+
+## Structural DNA — there are no beats
+
+The rule every agent breaks. It goes first and in bold.
+
+> **A wall-text POV is ONE take with ONE static text block, and both are complete at frame 0.**
+
+No hook beat. No build. No reveal. No word-pop, no fade-in, no line-by-line arrival, no cut,
+no push-in, no transition, no end card. The four charges still exist but they **do not fire
+in series** — three of them fire at frame 0 simultaneously and the fourth fires in the
+comments:
+
+| Charge | Where it lives |
+|---|---|
+| 🪝 Hook | The wall's first six words, plus the fact that a screen dense with text is itself an interrupt in a feed of faces |
+| 🔄 Loop | **Literal.** The video ends before the reading does. The loop mechanic is the platform's own loop-around |
+| 😍 Payoff | Recognition. "This is exactly it." There is no product reveal, no result, no number |
+| 🎣 Bait | The wall's final line asking a judgeable question, **and** the post caption |
+
+### Why animating the text is fatal
+
+An agent's reflex is to reveal the wall line by line, or to word-pop it, "so it's not static".
+Do not. Three separate reasons, all load-bearing:
+
+1. **It breaks the read-loop.** The viewer's second pass through the loop is a *re-read from
+   where they got to*. If the text rebuilds itself every loop, they cannot resume — they have
+   to wait for line 9 to arrive again. The retention mechanic dies on the second play.
+2. **It breaks frame 0.** Frame 0 is the thumbnail and the scroll-stop. A wall that is
+   one-tenth built at frame 0 has nothing to stop anyone with.
+3. **It breaks the native tell.** Nobody's phone animates text into existence. Animation is
+   the single clearest signal that a video was made in an editor, and this format survives
+   entirely on not looking made.
+
+### Length
+
+**`duration = words / 8`, clamped to 8–12 seconds.** Length is not a choice and it is not a
+style. Write the wall, count the words, divide by eight. A 71-word wall is 8.9s; a 52-word wall
+clamps up to the 8.0s floor.
+
+That is well past the references' 5.1s, in both directions of the argument. They were cut to a
+length the poster liked rather than to the wall, and they are too short to carry a trending
+sound.
+
+**Neither direction is free.** A clip that is too short leaves the viewer too early to feel
+committed. A clip that is too long lets them finish in one play, which removes the loop
+entirely — and a wall that can be finished in one pass is just a caption. Half is the point.
+
+### The two modes — MIRROR and TURN
+
+Decide before you write a word. The mode changes the last line, whether the offer is named,
+and what the gate allows.
+
+| | **MIRROR** | **TURN** |
+|---|---|---|
+| What the wall is | A confession or truth-bomb that never resolves | A confession whose last 1–2 lines pivot to what changed |
+| The offer | Never in the wall. Handle + post caption only | Named in the pivot, once, plainly |
+| Last line | A judgeable question, or a flat unresolved statement | The pivot, then stop. No CTA after it |
+| Reach | High. It is shareable because it is not an ad | Lower. People recognise the shape |
+| Intent | Low. Almost nobody clicks. They comment and share | Higher. The people who do click are warm |
+| Default | **Yes.** Run 4 MIRROR to 1 TURN | Only when you already have reach to convert |
+
+**MIRROR is the default and it is not a compromise.** A pure mirror post is what earns the
+account the distribution that makes the occasional TURN post worth anything. An account that
+only posts TURN videos is an ad account and gets treated like one.
+
+**The mode is declared in the build log before writing**, because a wall written as a MIRROR
+and then "just given a little pivot at the end" is the most common failed build in this
+format — the pivot arrives as a betrayal and the comments say so.
+
+---
+
+## The wall — the only thing you actually write
+
+### Pick the speaker frame first
+
+Who is talking, and to whom. Four frames, and they are not interchangeable. **Reference A and
+Reference B both use attributed speech**, which is not an accident — see below.
+
+| Frame | Shape | Example opening | What it buys |
+|---|---|---|---|
+| 📻 **Overheard** | You are quoting something you saw or were told | *"I saw a tiktok saying …"* · *"my therapist said …"* | You do not own the claim, so you can post a harsh one without being harsh |
+| 🗣 **Quoted** | You are reporting what a specific person said to you | *"during our last fight she looked at me and said …"* | Maximum specificity, zero exposure. The other person said it |
+| 🕯 **Confession** | First person, present tense, admitting something | *"i keep telling people i'm fine and …"* | Highest intimacy. Highest risk — it is *you* on the hook |
+| ⚔️ **Accusation** | Second person, naming what the viewer does | *"you don't actually want advice, you want …"* | Sharpest. Use rarely. Fires the comment section but burns goodwill fast |
+
+#### Attribution is the mechanism, not a decoration
+
+Both references wrap the claim in someone else's mouth — a tiktok, a partner mid-fight — and
+then the poster says almost nothing. Reference A's *entire* contribution is three words:
+**"Is this true?"**
+
+That structure is doing three jobs at once and it is worth naming all of them:
+
+1. **The claim can be as hard as it needs to be.** A harsh truth stated flatly reads as
+   arrogant. The same truth quoted reads as reporting.
+2. **The comment section is pre-loaded.** The viewer is not asked to react to *you*, they are
+   asked to **adjudicate a third party**. People will not tell you their opinion; they will
+   absolutely tell a stranger they are wrong.
+3. **It survives being wrong.** If the claim is over-stated, the comments correct the quote,
+   not the account. The engagement is identical and the positioning is intact.
+
+**On the ⚔️ accusation frame you lose all three at once.** That is the trade, and it is why
+the accusation frame is a once-in-ten post, not a house style.
+
+### The grammar
+
+- **One block. No headings, no bullets, no emoji, no numbering, no bold.** The moment the
+  wall has structure it reads as a slide.
+- **Quotation marks around quoted speech, curly not straight** (`" "` and `'`). Straight
+  quotes are a typing tell from a code editor and they look wrong at 44px.
+- **Ellipses and lowercase `i` are fine.** Reference B uses both. They read as typed.
+- **No line breaks inside the quote.** Let it wrap. See *Typography DNA* — hand-breaking is
+  the single loudest "made in an editor" signal in this format.
+- **One paragraph break, maximum**, and only to separate the poster's own closing line from
+  the quote (Reference A does exactly this: the quote, a blank line, *"Is this true?"*).
+- **End on the sharpest clause.** No summary sentence. No "anyway". No tidy conclusion. The
+  wall should stop a beat before you are comfortable stopping.
+
+### The specificity ladder — the single biggest lever
+
+The same claim, four rungs. Only rung 3 and above are postable.
+
+| Rung | Example | Why it fails / works |
+|---|---|---|
+| 0 — abstraction | *"communication is important in relationships"* | Nobody has ever felt this |
+| 1 — named feeling | *"i feel unheard sometimes"* | True of everyone, therefore about no one |
+| 2 — named situation | *"every time we argue it gets worse"* | Getting closer. Still a category, not a memory |
+| 3 — named mechanism | *"every small issue turns into an argument, then into distance, then into something way bigger than it needed to be"* | ✅ This is Reference B. The **escalation is described step by step**, so the reader recognises their own sequence |
+| 4 — named consequence | *"i've learned to stay quiet, because it hurts less than trying to be understood"* | ✅ The behaviour the mechanism produced. The strongest line in either reference |
+
+**Rung 3 is a chain, not an adjective.** "It escalates" is rung 2. "Argument → distance →
+something bigger than it needed to be" is rung 3, and it is longer, which is a feature here
+and nowhere else in the catalog.
+
+**Climb the ladder inside one wall.** Reference B opens at rung 2 (*"it never feels safe"*),
+walks through rung 3, and lands on rung 4. That is the shape: situation → mechanism →
+consequence. It is also, not coincidentally, exactly how a real person describes a problem
+they have thought about for months.
+
+### The judgeable claim — why "Is this true?" is the engine
+
+A wall that is merely *relatable* gets a like. A wall that is **arguable** gets a comment, and
+comments are distribution.
+
+Make the wall contain something a reasonable person could push back on:
+
+- A **generalisation about a group** — *"when a man loses interest, he will …"* (Reference A).
+  Half the comments will say "not all", and that is the point.
+- A **causal claim** — *"a healthy relationship turns conflict into connection"* (Reference B).
+  Sounds like wisdom, is actually a thesis, and people will litigate it.
+- A **behaviour someone will defend** — *"i've learned to stay quiet"*. The replies are half
+  "same" and half "that's the problem".
+
+Then, optionally, **ask for the verdict in three words.** *"Is this true?"* · *"am i wrong"* ·
+*"tell me it's just me"*. Set on its own line after a blank line.
+
+**Never write a question that has an obvious answer**, and never write "thoughts?". The ask
+has to be a real fork or it reads as engagement-farming, which it is, badly.
+
+### The cold-viewer test — cover the offer and read it again
+
+Hand the wall, as plain text, with the brand name removed, to someone who has never heard of
+the offer.
+
+- **They must not be able to tell it is an ad.** Not "they forgive it" — they must not be able
+  to tell.
+- **They must be able to name the person who wrote it.** If the answer is "a company", rewrite.
+- **They should want to reply.** If their instinct is to nod and move on, the claim is not
+  judgeable. Go back a section.
+
+### Banned walls
+
+Any of these and the build is dead, regardless of how it renders:
+
+- **A list of benefits with the line breaks removed.** The most common failure. It has
+  paragraph shape and ad content, and readers detect it in about 400ms.
+- **A fake statistic.** *"93% of founders never …"* — an invented number in a confession is a
+  lie wearing a confession's clothes, and it draws the harshest correction of any failure here.
+- **A resolved MIRROR.** In MIRROR mode the wall does not get to feel better at the end.
+- **A CTA in the wall.** Not at the end, not in parentheses, not as "(link in bio)". The front
+  matter blocks the obvious phrasings; the rule covers the clever ones.
+- **A named real competitor doing something bad.** Not a rule about taste. It is a legal
+  exposure that belongs to the customer, not to you.
+- **An earnings, health, or appearance outcome.** *"i went from 0 to $40k/mo"* attached to a
+  confession is exactly the shape platform enforcement is tuned for.
+- **A wall written to fit a clip you already picked.** Wall first, always. A wall reverse-
+  engineered from footage lands on rung 1 every single time.
+
+---
+
+## Casting the scene
+
+### The two classes
+
+| | 🚗 **POV** | 🙂 **UGC scene** |
+|---|---|---|
+| What it is | The camera is the viewer's eyes. No person on screen | A real person on camera, not talking, doing almost nothing |
+| Reads as | The viewer's own thought | Someone else's thought, with a body attached to it |
+| Best speaker frame | 📻 Overheard · 🕯 Confession | 🗣 Quoted · ⚔️ Accusation |
+| Examples | Night drive through a windshield · walking a sidewalk · a train or bus window · rain on glass · a ceiling · a passenger-seat side window | Sitting in a parked car looking out · walking with headphones on · standing at a window · sitting on a floor |
+| Risk | Too dark and it is a black card with text on it | The face becomes the subject and the reading stops |
+
+Both references are POV. **POV is the default** because the empty gaze is what lets the wall
+become the viewer's own inner voice — the strongest thing this format does.
+
+**In UGC class the person must never look at the camera and must never move much.** A glance
+to lens converts the video into a talking-head with no sound, which is a different and worse
+format. Cast a profile, a back of a head, a figure walking away.
+
+### The congruence rule — mood matched, meaning empty
+
+The scene must **agree with the wall's temperature** and **contain none of its content**.
+
+| Wall temperature | Scene that agrees | Scene that steals |
+|---|---|---|
+| Late, tired, resigned | Night drive · empty street · rain on a window | Anyone crying. A face doing the emotion for the reader |
+| Restless, unresolved | Walking fast · a train window · a ceiling fan | Anything with a destination in shot |
+| Flat, cold, over it | A parked car at dusk · a grey window · still water | A sunset. Sunsets resolve, and MIRROR mode does not resolve |
+| Quietly hopeful (TURN only) | First light · a road opening up · a window filling | Anything celebratory. It cashes the cheque too early |
+
+**If the wall is about work and the scene is an office, you broke the rule.** Literal is the
+enemy. The scene should be the *place the thought occurs*, never the place the problem lives.
+
+### The darkness budget — casting is a legibility decision before it is a mood decision
+
+This is the non-obvious rule of the whole file, and it is measured.
+
+The format uses **no plate behind the text — ever** (see *Visual DNA*). Plate-free type is
+only readable over a dark, calm background. So the requirement "the scene must be dark" is
+not an aesthetic; **it is what buys the plate-free look, and the plate-free look is what makes
+the video read as native.** Cast bright and you are forced into a plate, and the plate turns
+the video into an editor's export.
+
+Measured across all 51 sampled frames of both references, inside the block's own rect —
+these are `band-measure.py`'s own numbers, reproducible with the command in Appendix B:
+
+| Measurement | Reference A | Reference B | **Gate** |
+|---|---|---|---|
+| Median luma behind the block, worst frame | 18 | 17 | **≤ 60** |
+| Mean luma behind the block, worst frame | 38 | 39 | ≤ 90 |
+| % of band pixels over 120, worst frame | 8.5% | 8.6% | **≤ 15%** |
+| p98 luma (specular hits — headlights, streetlights) | 175 | 176 | no gate |
+| Frame-to-frame motion | 3.6 | 3.8 | 1.5–20 |
+
+Two things to take from that table:
+
+- **The references sit far inside the gate.** The gates are set to pass them with real headroom
+  and to fail a daylight clip, not to be a tight fit around two videos.
+- **Bright point-lights are FINE and the standard deviation lies about them.** The band's
+  standard deviation across both references is 43–47, which the general `HARNESS.md` treatment
+  table would read as "busy → needs a plate". It is wrong here. The variation is a handful of
+  streetlights a few pixels across; the type is 40px+ with a drop shadow and it sails over
+  them. **Gate on the median and on the fraction of bright pixels, never on the standard
+  deviation.** `band-measure.py` (Appendix B) implements exactly this.
+
+Run Appendix B on a candidate **before** you build. It is free and it is the difference
+between recasting in thirty seconds and recasting after a render.
+
+### Sourcing — and an honest warning about the free shelf
+
+```bash
+vidfarm public-raws --category ugc-reaction --limit 200   # 180 clips — the UGC-class shelf
+vidfarm public-raws --category lifestyle    --limit 200   # people walking, outdoors, at night
+vidfarm public-raws --category b-roll       --limit 200
+vidfarm public-raws --query walk                          # keyword search, one word at a time
+```
+
+**The free public raws shelf is thin on true POV footage, and you should know that before you
+start looking.** Searched at the time of writing: `pov` → 0 results. `driving` → 0. `road` → 0.
+`window` → 0. `rain` → 0. `night` → 2. The shelf's `setting:car` bucket holds 5 clips, and
+they are people *sitting in* cars, not windshield POV.
+
+What the shelf **does** have, and what it is genuinely good for:
+
+- **UGC class — but read this before you count on it.** `ugc-reaction` + `lifestyle` describe
+  people walking outdoors, sitting in parked cars, standing at night, and the descriptions are
+  accurate. What they do not say is that **the shelf is selfie footage**: a face, centred, on
+  lens, for the clip's entire duration. On the first dishcover.io batch all seven plausible
+  candidates failed gate 1 outright (worst-frame median luma 121–185 against a ceiling of 60),
+  and the two that passed after grading still put the wall on top of somebody's face while they
+  looked at the reader. **Treat this shelf as a last resort for this format**, and read a
+  contact sheet before you grade anything.
+- **The `actor_<uuid>` token.** Every tagged public raw carries one actor id at the tail of its
+  `summary` string. Read it off a card you like, then `vidfarm public-raws --query actor_<uuid>`
+  to get every other clip of the same person. For a serialised account (see *Bulk generation*)
+  this is how you get one recurring face across thirty posts for free.
+
+For **POV class**, the honest paths, cheapest first:
+
+| Path | Cost | Notes |
+|---|---|---|
+| **Shoot it** | $0 | A phone on a dashboard mount for one 20-minute night drive yields a year of backgrounds. This is genuinely the right answer and agents skip it because it is not a CLI call |
+| **Free-for-commercial stock** | $0 | The path that actually worked on the first dishcover.io batch. Pexels and Pixabay block a plain `curl` (403); **Mixkit does not**, and its free licence permits commercial use with no attribution. `https://mixkit.co/free-stock-video/<topic>/` lists the ids, and `https://assets.mixkit.co/videos/<id>/<id>-1080.mp4` is the file. Of 12 night clips pulled that way, **3 passed gate 1 ungraded** — better odds than the entire public-raws shelf |
+| `vidfarm handoff raws --keywords "night drive pov,rain window" --purpose "…"` | $0 | Mints a copy-paste sourcing brief for a human: what to search, how to download, and the `vidfarm raws scan` follow-up |
+| `vidfarm raws scan` / the clipper | $0 | Ingest footage you already have rights to |
+| Generated plate | $ (cost mode `hybrid`+) | A generated night road loops cleanly and has no rights question. It also looks generated on a big screen — acceptable here **only** because the background is deliberately unremarkable and 60% covered in text |
+
+**Whatever the path: one background clip is reusable across an entire batch.** See *Bulk
+generation*. The cost of sourcing amortises to near zero, which is why it is worth doing
+properly once instead of badly thirty times.
+
+### Rights tiers — read this before you cast for a paying customer
+
+| Tier | Source | Safe for a client? |
+|---|---|---|
+| ✅ **Owned** | The customer's footage, or footage you shot | Yes, always |
+| ✅ **Licensed** | Vidfarm public raws, cleared stock | Yes |
+| ✅ **Generated** | AI-generated plate | Yes. Disclose it in the handoff |
+| ⚠️ **Scraped ambient** | A night-drive clip pulled off a platform | **The customer's call, in writing.** Ambient POV with no identifiable person is the low end of the risk range, and it is still not yours |
+| 🚫 **Identifiable person, scraped** | Any recognisable face you did not license | No. Not for a client, not ever |
+
+**Declare the tier in the handoff.** An agent that quietly ships tier ⚠️ has moved a risk onto
+the customer without telling them, and that is the failure mode, not the clip.
+
+---
+
+## Visual DNA
+
+### The canvas
+
+**1080 × 1920, 30fps.** Both references, exactly. If the source is 4:3 or 16:9, **fill the
+frame** — scale up and crop, do not letterbox and do not blur-bar. A blur-bar is an editor's
+solution and the frame is supposed to look like it came off a phone.
+
+### The block geometry — measured, not guessed
+
+Both references, measured off the rendered frames:
+
+| Property | Reference A | Reference B | **Spec** |
+|---|---|---|---|
+| Block vertical centre | 50.0% | 49.9% | **48–52% of frame height** |
+| Block vertical span | 34.9% → 65.2% | 30.7% → 69.0% | 30–40% of frame height |
+| Ink width (leftmost to rightmost lit pixel) | 66.5% | 67.7% | **66–70% of frame width** |
+| Box horizontal centre | 49.9% | 50.0% | **48–52% — centred** |
+| Lines | 10 | 14 | an output, never a target |
+| Font size | ~46px | ~40px | an output. See the fitter |
+| Line height | 1.22 | 1.25 | **1.25** |
+
+**The block is vertically centred on the frame.** Not on the lower third, not on the upper
+third. Dead centre, both references, within a fifth of a percent. This is the single most
+copyable number in the file and it is also the one a caption-placement habit will fight you
+on — the general `HARNESS.md` rule about finding the quietest third does not apply, because
+the whole frame is deliberately quiet and the block is 35% of it.
+
+**Centred on both axes, and measure it per line, not per block.** Both references sit at
+49.9% and 50.0% horizontally.
+
+That number is worth a warning, because it is easy to measure wrong and the wrong answer is
+plausible. Take the union extent of every lit pixel in the block's rows and reference B reports
+**43.9%** — a confident-looking 6%-off-centre reading that would have you deliberately
+offsetting the box to imitate a "hand-dragged" placement that does not exist. The cause is a
+streetlight sitting inside the block's rows, dragging the union's left edge outward. **Measure
+each text line's own centre and take the median across lines** (Appendix C does this): the
+light can only corrupt the one line it overlaps, and the median outvotes it. Both references
+then land on 50.0%.
+
+The general lesson, which applies to every measurement in this file: **on footage with point
+lights, any statistic built from an extent or a variance is unreliable. Use medians.** The same
+correction is why the darkness gate keys on the band's median rather than its standard
+deviation.
+
+### No plate. Ever.
+
+No background colour behind the text. No rounded rectangle. No frosted panel. No translucent
+slab. No per-line highlight. Not at any opacity.
+
+The plate is the thing that makes a video read as *made somewhere else and uploaded*, and it
+gets worse the moment the text wraps, because the slab's own edges become a shape competing
+with the frame. In a format whose entire proposition is "this is a real person's screen", a
+plate is the only defect that cannot be fixed in the edit.
+
+**Legibility comes from three places instead:**
+
+1. **The casting.** Median luma ≤ 60 behind the block. This does 80% of the work and it is
+   decided before you open an editor. (See *The darkness budget*.)
+2. **A soft drop shadow, no stroke.**
+   ```css
+   text-shadow: 0 2px 10px rgba(0,0,0,.60), 0 0 3px rgba(0,0,0,.50);
+   ```
+   Diffuse, dark, generous. Its job is the **specular case** — the measured p98 in both
+   references is ~176, meaning streetlights and headlights genuinely do sweep across the
+   block, for a few frames, over a few percent of its area. The shadow is insurance for those
+   frames. A hard stroke would survive them too and would look like a sticker; the shadow
+   survives them and looks like a phone.
+3. **A global grade on the background, not a gradient behind the text.** See below.
+
+### Pushing the background down — grade, don't gradient
+
+If the scene measures a little too bright, the reflex is a dark gradient behind the text.
+Don't: a gradient has a visible edge, and a visible edge is a plate with soft corners.
+
+Grade the **whole clip** instead, uniformly:
+
+```bash
+# lift blacks down and pull exposure — applies to the entire frame, so there is no edge
+ffmpeg -i scene.mp4 -vf "eq=brightness=-0.10:contrast=1.05:saturation=0.90" -c:a copy graded.mp4
+```
+
+Re-measure with Appendix B afterwards. Two things to hold:
+
+- **Grade to the gate, not past it.** A background crushed to pure black stops being a place
+  and the video becomes a black card with text, which loses the entire mood contribution.
+  Median luma in the 15–45 range is where both references live and it is the right target.
+- **Never blur the background.** Blur is this format's loudest slop tell — it says "I knew the
+  background was competing", and a background that needed blurring was miscast.
+
+### Everything else
+
+Banned outright, and `vidfarm qa` flags most of them as slop:
+
+logos · watermarks · a URL on screen · progress bars · pricing cards · feature grids · benefit
+chips · CTA buttons · frosted panels · stickers · emoji on the frame · arrows · circles drawn
+on things · zooms · push-ins · Ken Burns · shake · film grain overlays · light leaks · vignettes
+added in post · a fade from or to black · a transition of any kind · a second clip.
+
+The list is long on purpose. **Every item on it is something an editor adds to a video that
+feels too plain**, and *too plain is the format*.
+
+---
+
+## Typography DNA — a screenshot, not a title card
+
+### The font regime
+
+| Property | Value | Why |
+|---|---|---|
+| Family | **TikTok Sans**, self-hosted, weight 700 | The platform's own text tool. Anything else is legible and wrong |
+| Fallback chain | **none** | A fallback means a missing font renders as a *different* font and nothing tells you. Self-host the `.woff2` so there is nothing to fall back *from* |
+| Weight | 700 | Measured stem-to-cap ratio on both references is ≈0.21 — Bold, not Black. 900 reads as a meme caption, which is the wrong format |
+| Case | sentence case **or** all lowercase | Both references, one each. **Never all-caps** — all-caps is shouting and this format whispers |
+| Colour | `#FFFFFF` | Not off-white, not warm white |
+| Alignment | **centre** | Each line centred, ragged both sides |
+| Line height | 1.25 | |
+| Letter spacing | 0 | |
+
+### Let it wrap. Do not hand-break the lines.
+
+Look at Reference A: *"… he will / make it seem like he still likes / you but can't give you as
+much time / as before because …"*. Every break lands mid-clause. **That is correct and it is
+the point.** It is what a text box does when a human types into it and drags the sides.
+
+A hand-broken block — lines broken at clauses, near-equal length, a shallow ragged edge — is
+*typeset*. It reads as designed, and the moment it reads as designed the wall stops being
+someone's private thought and becomes a quote card. This is the exact opposite of the
+instruction in `meme-recaption`, where the caption *is* a card and hand-breaking is right.
+**Two formats, opposite rules, and the reason is the same: match the tool the reader believes
+made it.**
+
+So: set a fixed box width, set `text-align:center`, and let the browser wrap. Then read the
+result and only intervene if a line ends up as a single orphaned word — in which case adjust
+the **box width by 1–2%**, never the line breaks.
+
+**The one permitted manual break is the paragraph break** before the poster's own closing line
+(Reference A's blank line before *"Is this true?"*). One, maximum.
+
+### Size is an output of word count
+
+Never pick a font size. Solve for it. The block has a fixed height budget, so size falls out
+of how many characters you wrote:
+
+```
+block_height ≈ chars × ADV × line_height × size² / box_width
+```
+
+where **`ADV = 0.58`** — the measured average glyph advance per character for TikTok Sans 700
+in mixed case — and **`box_width = 0.72 × frame width`**.
+
+Solving for a target block height of 34% of frame:
+
+```
+size = sqrt(target_height_px × box_width_px / (chars × 0.58 × 1.25))
+```
+
+Appendix A implements this, then does a **real greedy wrap** to confirm the line count and
+reconciles the two in both directions, clamped to **[30, 52]px**. Run against the two
+references' own walls it returns:
+
+| | Fitter | Actual | |
+|---|---|---|---|
+| Reference A (55 words, 276 chars) | 47px | 46px | ✅ |
+| Reference B (83 words, 470 chars) | 38px | 40px | ✅ |
+
+**The line count will run 1–2 lines over the real render.** Greedy wrapping wastes each line's
+tail and the integer chars-per-line truncates, so the fitter is systematically ~8%
+conservative. That is the right direction to be wrong in — it never overflows the block — but
+it means the fitter's reported span is a ceiling, not a prediction. If the rendered still
+reads small, raise `--target-h` a point or two rather than hand-setting a size.
+
+**If the fitter clamps at 30px, the wall is too long — cut words, do not shrink further.** Type
+under 30px on a 1080-wide canvas is under 2.8% of frame width and stops being readable on a
+phone held at arm's length, which is the only place this video will ever be watched.
+
+### Placement — centred, and the safe zone matters more than usual
+
+The block sits at 48–52% vertical centre, so with a 30–40% span it occupies roughly **30% →
+70% of frame height**. That is comfortably inside the 8–85% safe zone at both ends.
+
+**Check it anyway, and check it against the platform's own furniture.** A 40%-tall block
+centred vertically is the largest single object this format ever places, and if the wall runs
+long it grows from the centre outward in both directions at once. Reference B's span reaches
+69.0% — the caption row and the action rail on TikTok start eating the frame not far below
+that. If the fitter returns a span over 40%, cut words.
+
+### The handle
+
+In **MIRROR** mode the offer is not in the wall. It goes in the post caption, and — optionally
+— as a handle.
+
+```css
+.handle{
+  font-family:'TikTok Sans'; font-weight:700; font-size:26px;
+  color:rgba(255,255,255,.55);
+  letter-spacing:.02em;
+  /* no plate, same as the wall */
+  text-shadow:0 2px 8px rgba(0,0,0,.6);
+}
+```
+
+- **One line, under the block, centred with it, ~40px of air below the last line.**
+- **26px and 55% opacity.** It is attribution, not a CTA. It should be findable, not readable
+  at a glance — someone who screenshots the post can read it, and that is the whole job.
+- **The handle is the offer's name or domain. Nothing else.** No tagline. No "→". No emoji.
+- **The handle is optional and often better omitted.** A pure MIRROR post with no handle at all
+  is the highest-reach configuration; the account name under the video is already attribution.
+  Use the handle when the post is likely to be reposted as a screenshot.
+- **In TURN mode there is no handle**, because the offer is already named in the pivot and
+  naming it twice on one screen is the ad tell.
+
+---
+
+## Audio DNA
+
+The most-skipped strand, and a silent upload is an instant fail — the platform down-ranks
+soundless video and a muted autoplay of a silent clip has no signal that it is playing at all.
+
+### One flat ambient bed. That is the entire audio design.
+
+Measured on both references:
+
+| | Reference A | Reference B | **Spec** |
+|---|---|---|---|
+| Integrated loudness | −22.3 LUFS | −19.8 LUFS | **−23 to −18 LUFS** |
+| Loudness range (LRA) | 2.1 LU | 0.7 LU | **≤ 3.0 LU** |
+| Channels / rate | 2 / 44.1kHz | 2 / 44.1kHz | keep |
+
+**LRA of 0.7 is the number to internalise.** It means the audio is essentially a constant —
+road noise, tyre hum, wind, rain, a room tone. No melody, no beat, no build, no drop, and
+categorically **no speech**.
+
+Why it must be flat:
+
+- **The reader is reading.** Any audio event — a drum hit, a vocal, a chord change — pulls a
+  reader's eye off the line they are on. A flat bed is *sonic wallpaper* and that is a
+  compliment here.
+- **The video loops 3–5 times per viewer.** A track with any structure becomes maddening on
+  the third pass. A hum does not.
+- **The loop seam must be inaudible.** A bed with rhythm has a seam you can hear at the
+  wrap-around, and an audible seam tells the viewer they have looped — which is exactly the
+  moment they decide to leave. See below.
+
+### Sourcing the bed
+
+1. **Default: mute the scene and lay your own bed.** `data-volume="0"` on the video, the bed
+   on its own track. This is the default because a background clip's own audio is a liability
+   you did not choose: it carries wind roar, a voice, a passing siren, someone's music — all of
+   which are audio *events*, all of which pull a reader off the line they are on, and one of
+   which is a rights question you now own. On the first dishcover.io batch both candidate plates
+   failed on their own audio, in opposite directions: one measured **LRA 7.5 LU** (structured)
+   and the other was **silent at −70 LUFS**. Neither is audible as a problem when you play it.
+
+   A flat bed is free to synthesise and always congruent:
+
+   ```bash
+   ffmpeg -f lavfi -i "anoisesrc=c=pink:r=44100:a=0.9:d=30" \
+     -af "lowpass=f=520,highpass=f=45,loudnorm=I=-21:LRA=1:TP=-2.0" -ac 2 bed/tone.m4a
+   ```
+
+   Keep the scene's own audio only when you have **measured** it (LRA ≤ 3.0, no speech), you own
+   the footage, and it is genuinely the right room tone. That is a deliberate exception, not the
+   starting point.
+2. **If the source audio is unusable** (wind roar, a voice in the car, a clipped mic), replace
+   it with a room tone or road-noise bed via `/media-use`. Match the scene: a night drive gets
+   road noise, a window scene gets rain, a walk gets footsteps and distant traffic.
+3. **Trending audio is a poster-side decision, not a build-side one.** Ship the video with its
+   ambient bed. If the poster wants a trending sound, the platform's own editor lays it over
+   the top — and it will replace your bed, which is fine, because you built a video that works
+   silent-with-captions-off *and* under someone else's audio.
+
+Normalise to spec:
+
+```bash
+ffmpeg -i in.mp4 -af "loudnorm=I=-21:LRA=3:TP=-1.5" -c:v copy out.mp4
+```
+
+### The loop seam
+
+The video will be watched 3–5 times back to back. **The join from the last frame to the first
+frame is a real cut that you never see in your editor and every viewer sees three times.**
+
+- **Cut on continuous motion, at a matched moment.** A drive down a straight road at constant
+  speed joins almost invisibly. A drive that slows to a stop at the end and starts moving at
+  frame 0 has a visible lurch.
+- **Never end on a brake light, a turn, a stop, or an arrival.** Anything that reads as
+  "finished" makes the wrap-around feel like a glitch.
+- **Never fade audio out at the tail.** A fade-out followed by full level is the loudest
+  possible seam. Keep the bed level flat to the last sample — which the LRA ≤ 3.0 gate already
+  pushes you toward.
+#### Ping-pong the plate — the seam problem, solved arithmetically
+
+**Cut half the duration, then play it forward and reversed.** The last frame *is* the first
+frame, so the join is not a cut at all.
+
+This became necessary when `duration = words / 8` made the clips longer: more drift between
+first and last frame means a bigger jump. Measured on an 8.9s aerial plate:
+
+| | Seam (mean abs frame delta) | Clip's own median frame step | Join as a multiple |
+|---|---|---|---|
+| Straight cut | 18.0 | 3.4 | **5.3×** |
+| Ping-ponged | **0.4** | 3.1 | **0.1×** |
+
+0.1× means the loop join is a *smaller* change than one ordinary frame of playback. It is the
+default in `walltext-build.py`.
+
+- **Drop the duplicated middle frame** (`trim=start_frame=1`), or the turnaround holds for two
+  frames and reads as a hitch.
+- **Turn it off (`--no-pingpong`) when the plate has a directional subject.** A person walking
+  reverses into a moonwalk and it becomes the only thing anyone looks at. It is invisible on
+  ambient drift, aerials, water, rain and distant traffic — which is what this format casts.
+- **Never ping-pong audio.** Reversed picture can be imperceptible; reversed audio never is.
+  `--keep-scene-audio` therefore forces `--no-pingpong`.
+- **It halves the plate you need.** An 8.9s clip comes out of 4.45s of source, which matters
+  when a good plate is scarce.
+
+- **Check it by concatenating the render to itself and watching the join.**
+  ```bash
+  printf "file '%s'\nfile '%s'\n" "$PWD/out.mp4" "$PWD/out.mp4" > /tmp/l.txt
+  ffmpeg -f concat -safe 0 -i /tmp/l.txt -c copy /tmp/looped.mp4
+  ```
+
+---
+
+## The rules
+
+### Rule 1 — the wall is written before the clip is chosen, and it is never adjusted to fit the clip
+
+**Why:** a wall reverse-engineered from footage lands on the specificity ladder's rung 1 every
+time, because footage suggests moods and moods are abstractions. The wall comes from the
+`THE ACHE` line in the build log; the clip is cast to agree with it afterwards. If no clip in
+the shelf agrees, grade one or shoot one — do not soften the wall.
+
+### Rule 2 — every line earns its place, and the clip is what gets cut
+
+**Why:** the two are decided in that order and never together. Padding a wall to reach a
+duration produces exactly the video this format is trying not to be — a reader who feels a
+sentence that adds nothing leaves on that sentence, and no machine check in this file can see
+it. Setting the duration from the finished wall costs nothing and is the whole retention design.
+
+So: **run the deletion test on every line**, then set `duration = words / 8` so one play lands
+the viewer at the halfway mark — committed, and one pass from done. Write both the ratio and
+the line you cut into the build log. There is no minimum word count and no minimum ratio; a
+33-word wall carrying one clean observation is a finished video at 4.1s.
+
+### Rule 3 — nothing on screen moves except the background
+
+**Why:** three separate failures at once (breaks the re-read on the second loop, breaks frame
+0 as a thumbnail, breaks the native tell). No fade, no word-pop, no line arrival, no scale, no
+opacity ramp, no cut, no transition. The text block's `data-start` is `0` and its
+`data-duration` equals the full composition duration. There is no other timing in this format.
+
+### Rule 4 — no plate, and the casting is what pays for that
+
+**Why:** the plate is the single clearest "made in an editor" signal, and in a format built
+entirely on looking un-made it is unfixable in the edit. That makes the darkness budget a hard
+casting gate, not a preference: median luma ≤ 60 behind the block on every sampled frame, and
+≤ 15% of band pixels over 120. Measure with Appendix B **before** building, not after.
+
+### Rule 5 — frame 0 is the complete video
+
+**Why:** frame 0 is the thumbnail, the scroll-stop, and the first thing anyone reads. The full
+wall, the final background, and the handle are all present and legible at frame 0. In practice
+this needs an explicit poster still (a one-shot composition renders frame 0 before the video
+element has decoded anything, so frame 0 otherwise ships as an empty background). Appendix A
+writes the poster; the QA script checks it.
+
+### Rule 6 — the background is boring, and it is not about the wall's subject
+
+**Why:** every unit of meaning in the frame is a unit of attention not spent reading. Literal
+scenes are the specific trap — a wall about work over an office, a wall about a relationship
+over a couple. The scene is *where the thought happens*, never *where the problem lives*.
+
+### Rule 7 — MIRROR does not resolve, and TURN pivots exactly once
+
+**Why:** an unresolved confession is shareable because it is not an ad. A resolved one is an
+ad with a sad opening, the audience reads the shape instantly, and the comments say so. In
+TURN mode the pivot is one clause, names the offer once, and the wall stops — no CTA after it,
+no benefit, no second sentence.
+
+### Rule 8 — every specific in the wall is true, and there are no numbers
+
+**Why:** a rung-3 or rung-4 specific is what makes the wall land, and an invented specific is a
+fabricated confession — the harshest correction available in this format when someone catches
+it. Statistics in particular are banned outright: a confession does not cite data, so a number
+in a wall is *always* an ad tell, even when the number is real.
+
+**One exception, and only one: the TURN pivot may carry a single product fact.** In TURN mode
+the pivot *is* the ad — the wall has already stopped being a confession by the time it arrives —
+and one concrete number there does the work a paragraph of adjectives cannot (*"indexes 7,502
+dishes off real nyc menus"*). The exception is narrow on purpose: one number, inside the pivot
+clause, in TURN mode only. A number anywhere in a MIRROR wall, or anywhere in a TURN wall before
+the pivot, is the ad tell this rule exists to catch.
+
+### Rule 9 — the bait is the wall's last line and the post caption, never a card
+
+**Why:** an on-screen "comment below" converts the video back into an ad in one frame. The ask
+is either inside the wall as a judgeable question (Reference A's *"Is this true?"*) or it is in
+the post caption, and it should be in both. The post caption carries the same ask because many
+people reply from the caption without finishing the video.
+
+### Rule 10 — production floor
+
+One take · no cuts · no transitions · 1080×1920 · TikTok Sans 700 self-hosted with no fallback
+chain · text inside the 8–85% safe zone · the wall's `data-start` is 0 · a real frame-0 poster ·
+audio present, flat, and normalised · no logo, watermark, URL, or brand chrome on screen · the
+rights tier declared in the handoff.
+
+---
+
+## Cost-saving mode — the whole build at $0
+
+This format is the cheapest in the catalog. Nothing about it needs to cost money.
+
+| Step | Free path |
+|---|---|
+| The wall | You write it. There is nothing to generate |
+| The scene | A phone on a dashboard for twenty minutes, or `vidfarm public-raws` (free), or footage the customer already owns |
+| Type + layout | Appendix A. Local HTML, no cloud |
+| Grade + normalise | `ffmpeg`, local |
+| Frame-0 poster | `ffmpeg -vframes 1`, local |
+| Render | local render (`vidfarm render --local`), not cloud |
+| QA | Appendices B and C, local, plus `vidfarm qa <dir> --harness ./experimental/wall-text-pov-ugc.md` |
+
+Set `vidfarm cost-mode minimize` for the batch. There is no step in this file that a billed
+operation improves.
+
+---
+
+## Bulk generation — this format is built for it
+
+The economics are unusual and worth being explicit about: **the expensive ingredient is
+reusable and the cheap ingredient is the variable.**
+
+```
+1 background clip  ×  N walls  =  N videos
+```
+
+One 20-minute night drive, cut into six 5-second segments, is six backgrounds. Six backgrounds
+× thirty walls is a quarter's posting schedule, and every video after the first costs you
+nothing but the writing.
+
+**Serialise deliberately.** Both reference templates are the same creator, the same road, the
+same type treatment, published five days apart. That repetition is an asset, not laziness:
+
+- The account becomes **recognisable in the feed at a glance**, which is worth more than
+  variety in a format this simple.
+- The returning viewer knows the shape and starts reading immediately, which raises the
+  completion rate on every subsequent post.
+- The variable that carries all the learning is the **wall** — which is exactly the variable
+  you want to be testing.
+
+### Hold three constant, vary one
+
+| Vary this | To learn |
+|---|---|
+| **The wall's rung** (2 vs 3 vs 4) | How specific your audience needs it |
+| **The speaker frame** (overheard / quoted / confession / accusation) | How much attribution your claims need |
+| **The loop ratio** (2.5 vs 4.0 vs 5.5) | Where your audience's patience ends |
+| **The mode** (MIRROR vs TURN) | What a TURN post actually costs you in reach |
+| **The scene** | Almost nothing. Vary it last, and only for visual fatigue |
+
+**A batch where the wall and the background both changed teaches you nothing.** Hold the
+background — it is free to hold and it is the variable that matters least.
+
+Appendix E is a driver that takes a TSV of walls and one background and emits N composition
+directories.
+
+---
+
+## Quality gates — what is enforced, and by what
+
+Be honest about which half is machine-checkable. Three gates, and they catch different things.
+
+| Gate | Runs on | Catches |
+|---|---|---|
+| **1. Casting** — `band-measure.py` (Appendix B) | a candidate clip, before you build | Too bright · too busy · specular load. The cheapest gate by an order of magnitude |
+| **2. Structure** — `vidfarm qa <dir> --harness ./experimental/wall-text-pov-ugc.md` | the composition DOM | Front-matter `checks:` · slop furniture · safe zone · font regime · duration · text timing |
+| **3. Render** — `walltext-qa.py` (Appendix C) | the finished MP4 | Loop ratio · word floor · frame 0 and the last frame both live and both carrying the wall · block geometry · band luma across all frames · plate detection · audio LUFS and LRA · motion continuity |
+
+### ⚠️ `vidfarm qa` will fire `wall-of-text` on every video in this format. Do not fix it.
+
+Gate 2 emits this, verbatim, on a correct build:
+
+```
+! warn [wall-of-text] One static text layer carries 78 words held for 5.6s — a paragraph,
+       not a caption. A scrolling viewer reads none of it.
+     → Page it into kinetic cues: `vidfarm captions generate <dir> --style word-pop` …
+```
+
+**The suggested fix would destroy the format.** Paging the wall into 3–5-word kinetic cues
+removes the read-loop (Rule 2), empties frame 0 (Rule 5), and animates the text (Rule 3) — all
+three of the format's load-bearing properties, in one command that looks like it is helping.
+
+The warning is correct in general and wrong here. It is written for a format where text
+supports a voiceover; in this one the text **is** the video, and "a scrolling viewer reads none
+of it" is a description of the mechanic rather than a defect — the viewer is not supposed to
+finish it on the first pass.
+
+Everything else in gate 2's output is live and should be read normally. Note also that
+`vidfarm qa` reads `composition.html`, so symlink or copy `index.html` to that name before
+running it.
+
+**What no gate can settle**, and therefore lives in the pre-flight checklist as a `- [ ]`:
+whether the wall is on rung 3 or rung 1 · whether the claim is judgeable · whether the scene is
+congruent or literal · whether a cold reader can tell it is an ad · whether MIRROR mode
+actually failed to resolve. Those are the ones that decide the video, and pretending a linter
+settles them would be a lie.
+
+---
+
+## Pre-flight checklist
+
+**The mechanic**
+- [ ] The loop ratio is computed and written in the build log, and it is between 1.8 and 2.4
+- [ ] The deletion test was run line by line — name the line you cut, or why nothing could go
+- [ ] The two-thirds test was attempted: the wall does not survive being cut to two-thirds without losing an idea
+- [ ] No wind-up, no permission slip, no restatement, no hedge stack, no tidy close
+- [ ] The clip length is `words / 8` (clamped 8–12s), so one play reaches the halfway mark — ratio 1.8–2.4
+- [ ] If the wall is under 64 words: the single-read trade was chosen deliberately, and the wall was NOT padded to recover the ratio
+- [ ] The wall was written first and the duration derived from it, never the other way round
+- [ ] Nothing on screen moves except the background: no fade, no word-pop, no line arrival, no cut, no transition
+
+**The wall**
+- [ ] The mode (MIRROR / TURN) was declared before writing, and the wall matches it
+- [ ] The speaker frame was chosen deliberately, and attribution is doing the work it should
+- [ ] The wall reaches rung 3 or rung 4 of the specificity ladder — name the rung
+- [ ] There is a judgeable claim in it that a reasonable person could argue with
+- [ ] The cold-viewer test was actually run on the plain text with the brand removed
+- [ ] MIRROR mode: the wall does not resolve. TURN mode: it pivots exactly once and then stops
+- [ ] No invented specifics, no statistics, no earnings/health/appearance outcome, no named competitor
+- [ ] Lines are auto-wrapped, not hand-broken; at most one manual paragraph break
+
+**The scene**
+- [ ] The scene agrees with the wall's temperature and contains none of its content — it is not literal
+- [ ] Appendix B was run on the clip **before** the build, and it passed
+- [ ] The clip is one unbroken take with continuous motion and no cut inside it
+- [ ] UGC class only: nobody looks at the camera
+- [ ] The rights tier is declared in the handoff, and tier ⚠️ was the customer's call
+
+**Production**
+- [ ] No plate, no gradient behind the text, no blur on the background — legibility came from casting plus a soft shadow
+- [ ] Block centre is 48–52% on BOTH axes, and the horizontal centre was measured as a per-line median (not a union extent — a light in the block's rows corrupts that)
+- [ ] Font size was solved by the fitter, not chosen — and it did not clamp at 30px
+- [ ] TikTok Sans 700, self-hosted, **no fallback chain in the font stack**
+- [ ] Frame 0 carries the complete wall over the real background — there is an explicit poster still
+- [ ] The last frame also carries the wall (it loops; there is no tail)
+- [ ] Audio is present, flat (LRA ≤ 3.0), normalised to −23…−18 LUFS, and contains no speech
+- [ ] The plate is ping-ponged (or `--no-pingpong` is justified by a directional subject), and the seam was checked by concatenating the render to itself
+- [ ] No slop furniture, and `vidfarm qa` is otherwise clean
+
+**Whole-video review** — on the render, not the plan
+- [ ] A contact sheet of ~8 stills was read as one image: the block does not drift, the type does not change size, the background does not brighten past the gate at any point
+- [ ] Two frames from opposite ends of the clip were compared — a frozen render passes duration, frame-count and audio-hash checks and looks fine in a single still
+- [ ] The video was watched three times through the loop without pausing, and the join was not distracting
+- [ ] The wall was read at natural speed on a phone-sized preview and every line was comfortably legible, including on the brightest frame
+- [ ] In a batch: this variant differs from its siblings in the **wall**, and the background was deliberately held constant
+
+---
+
+## Diagnosing a flop — read the mechanic, not the video
+
+| What the numbers say | Weak part | Fix |
+|---|---|---|
+| Barely any views | The first six words, or the frame-0 thumbnail | The opening clause is not an interrupt. Rewrite it. Check the poster actually rendered |
+| Views, average watch time ≈ the duration (ratio ≈ 1.0) | **The loop** | Nobody committed to reading. The wall is too short, too abstract, or the type is too small |
+| Watch time is a multiple of duration, but no comments | **The claim** | It was relatable, not judgeable. Nothing to argue with. Add a generalisation or a causal claim |
+| Comments, but all hostile | **The frame** | You used ⚔️ accusation, or an unattributed harsh claim. Move it into someone else's mouth |
+| Good numbers, zero clicks | Working as designed in MIRROR mode | This is not a failure. Run a TURN post against the audience it built |
+| Comments say "this is an ad" | **The mode leaked** | A MIRROR wall that resolved, a plate, a CTA, a stat, or a handle that got too loud |
+| Saves are high, shares are low | The wall is about them, not about a situation they share | Move from 🕯 confession toward 📻 overheard or 🗣 quoted |
+
+**Vary one thing at a time**, and the thing to vary is the wall. The background is free to
+hold constant and holding it is what makes the comparison mean anything.
+
+---
+
+## Appendix A — `walltext-build.py`
+
+Builds a complete composition directory: the graded scene, the frame-0 poster, the fitted
+type, and `index.html`. One command, no cloud, $0.
+
+```python
+#!/usr/bin/env python3
+"""
+Build one wall-text POV/UGC composition.
+
+usage:
+  walltext-build.py <scene.mp4> <wall.txt> <outdir>
+                    [--dur auto] [--in 0] [--handle "dishcover.io"]
+                    [--case lower|as-written] [--target-h 0.34]
+                    [--bed tone.m4a] [--keep-scene-audio] [--no-pingpong]
+
+What it does, in order:
+  1. reads the wall, counts words, and REFUSES to build below the 40-word floor
+     or above a loop ratio of 6.0 — the two failures that are invisible on the
+     render and fatal in the feed
+  2. cuts the scene to <dur> from <in>, scaled+cropped to 1080x1920, audio kept
+  3. SOLVES the font size from the character count (see "Size is an output")
+     and does a real greedy wrap to confirm the block height
+  4. writes media/poster.png — frame 0 of the cut scene. A one-shot composition
+     renders frame 0 before the <video> element has decoded anything, so without
+     this the thumbnail ships as an empty background. Frame 0 is the whole video
+     in this format (Rule 5), so this is not a nicety.
+  5. writes index.html with the vidfarm data-* contract
+
+What it deliberately does NOT do:
+  * grade the clip. Grading is a judgement made against band-measure.py's
+    numbers, so it stays a separate, visible step. A build script that quietly
+    darkens footage hides the casting failure it is compensating for.
+  * hand-break lines. See "Let it wrap".
+"""
+import subprocess, sys, pathlib, html, math, shutil
+
+if len(sys.argv) < 4:
+    sys.exit(__doc__)
+scene, wallpath, outdir = sys.argv[1], sys.argv[2], pathlib.Path(sys.argv[3])
+
+def opt(flag, default, cast=float):
+    return cast(sys.argv[sys.argv.index(flag) + 1]) if flag in sys.argv else default
+
+DUR      = opt("--dur", 0.0)            # 0 = auto: words/8, set after the wall is counted
+TIN      = opt("--in", 0.0)
+HANDLE   = opt("--handle", "", str)
+CASE     = opt("--case", "as-written", str)
+BED      = opt("--bed", "", str)         # path to a bed. Empty = synthesise a flat one
+OFFSET   = opt("--offset", 0.0)         # box centre, as a fraction of W off frame centre.
+                                        # 0.0 is correct: measured per-line, both references
+                                        # centre at 49.9% and 50.0%. The knob exists only to
+                                        # dodge a fixed bright object in a specific plate.
+TARGET_H = opt("--target-h", 0.34)      # block height as a fraction of frame height
+
+W, H, FPS = 1080, 1920, 30
+LINE_H    = 1.25
+# The BOX is wider than the INK. Both references measure 0.665 and 0.677 of frame
+# width from the leftmost to the rightmost lit pixel — but that is the widest LINE,
+# not the container it wrapped inside, which has to be wider still. 0.72 is the box
+# that reproduces both references' line counts; 0.68 is what you will measure back
+# off the render. Do not "correct" one to the other.
+BOX_FRAC  = 0.72
+ADV       = 0.58                        # measured glyph advance/char, TikTok Sans 700 mixed case
+SIZE_MIN, SIZE_MAX = 30, 52
+READ_WPS  = 4.0                         # plan against the FAST reader
+
+box_w = int(W * BOX_FRAC)
+
+# ---------------------------------------------------------------- 1. the wall
+raw = pathlib.Path(wallpath).read_text(encoding="utf-8").strip()
+if CASE == "lower":
+    raw = raw.lower()
+# collapse soft wrapping in the source file but KEEP deliberate blank lines,
+# which are the one permitted manual break (Reference A's line before "Is this true?")
+paras = [" ".join(p.split()) for p in raw.split("\n\n") if p.strip()]
+if len(paras) > 2:
+    sys.exit(f"FAIL: {len(paras)} paragraphs. The format allows one paragraph break, maximum.")
+
+words = sum(len(p.split()) for p in paras)
+chars = sum(len(p) for p in paras) + (2 if len(paras) > 1 else 0)
+read  = words / READ_WPS
+
+# DURATION IS DERIVED, NOT CHOSEN. One play must land the viewer at the halfway
+# mark of the wall: committed, and exactly one pass from finishing. That is
+# duration = words/8 (read_time/2), i.e. a loop ratio of 2.0.
+#
+# Pushing the ratio higher does not bank more plays, it banks fewer: at 4.0 the
+# viewer gets a quarter of the way in, feels the size of what is left and bails,
+# and a bail at 25% is a worse signal than a completed loop. Reference B is that
+# mistake — 83 words in 5.1s, where words/8 would have run 10.4s.
+# The 8s FLOOR is a distribution decision, not a reading one: a poster dropping a
+# trending sound on this in the platform's editor needs a recognisable phrase of a
+# track, not a fragment. Trending audio is the only algorithmic surface this format
+# has — no voiceover, no music of its own.
+AUTO = DUR <= 0
+if AUTO:
+    DUR = round(min(12.0, max(8.0, words / 8.0)), 2)
+ratio = read / DUR
+
+print(f"wall: {words} words, {chars} chars")
+print(f"read {read:.1f}s / clip {DUR:.2f}s{' (auto = words/8)' if AUTO else ''}"
+      f"  ->  loop ratio {ratio:.2f}  ({100/ratio:.0f}% read per play)")
+
+# NO word floor, on purpose. A floor is an instruction to pad, and padding is this
+# format's most common fatal failure. Anything out of band is a note about the CLIP.
+# Below 64 words the 8s music floor and the 50% rule cannot both hold, and the floor
+# wins. Saying "cut the clip" there would be advice to break the floor this script
+# just enforced, so that branch is suppressed and the trade is named instead.
+if ratio > 2.4:
+    print(f"NOTE: ratio {ratio:.2f} — only {100/ratio:.0f}% read per play. The clip is too "
+          f"SHORT; {words/8.0:.1f}s puts them at the halfway mark. Never add words.")
+elif ratio < 1.8 and words >= 64:
+    print(f"NOTE: ratio {ratio:.2f} — {100/ratio:.0f}% read per play, so they can nearly finish "
+          f"in one pass and the loop stops working. Cut the clip to {words/8.0:.1f}s.")
+elif words < 64:
+    kind = ("PARTIAL LOOP — they get most of the way through and still need a second pass"
+            if ratio >= 1.3 else
+            "SINGLE-READ — they finish inside one play and the loop mechanic is gone")
+    print(f"NOTE: {words} words vs the 8s music floor -> ratio {ratio:.2f} "
+          f"({100/ratio:.0f}% read per play). {kind}.")
+    print(f"      This is a trade, not a defect. Do NOT pad the wall to 64 words to recover "
+          f"the ratio — a padded 64 performs worse than a sharp {words}.")
+if AUTO and words / 8.0 > 12.0:
+    print(f"WARNING: words/8 = {words/8.0:.1f}s exceeds the 12s ceiling, clamped to 12.0 "
+          f"(ratio {ratio:.2f}). Cut the wall to ~96 words rather than accept this.")
+
+# Cheap padding tells. None of these is conclusive; all of them are worth a second look.
+import re as _re
+_low = " ".join(paras).lower()
+_hedges = sum(_low.count(h) for h in (" maybe ", " kind of ", " sort of ", " i think ", " probably "))
+if _hedges >= 3:
+    print(f"WARNING: {_hedges} hedges. A confession is not qualified — cut them.")
+for _p in ("i want to admit", "this might be controversial", "hear me out",
+           "just something i", "anyway,", "at the end of the day"):
+    if _p in _low:
+        print(f'WARNING: "{_p}" — permission slip or tidy close. Delete it and start on the claim.')
+
+# ------------------------------------------------- 2. solve the size, then verify by wrapping
+# Closed form (derivation in "Size is an output of word count"), then a real
+# greedy wrap to confirm — the closed form is accurate to ~5% and the wrap is
+# what actually decides the line count.
+size = math.sqrt((TARGET_H * H) * box_w / max(1, chars * ADV * LINE_H))
+size = max(SIZE_MIN, min(SIZE_MAX, int(round(size))))
+
+def wrap(text, px):
+    """Greedy wrap at the measured advance. Mirrors what the browser will do."""
+    cpl = max(8, int(box_w / (ADV * px)))
+    out, line = [], ""
+    for w_ in text.split():
+        trial = w_ if not line else line + " " + w_
+        if len(trial) <= cpl:
+            line = trial
+        else:
+            out.append(line); line = w_
+    if line:
+        out.append(line)
+    return out
+
+def block_lines(px):
+    n = 0
+    for i, p in enumerate(paras):
+        n += len(wrap(p, px))
+        if i < len(paras) - 1:
+            n += 1                      # the blank line
+    return n
+
+# Reconcile the closed form with the real wrap, in BOTH directions.
+#
+# Stepping down only is the obvious loop and it quietly costs type size: greedy
+# wrapping is ~8% more conservative than the closed form (integer chars-per-line
+# truncates, and every line wastes its own tail), so the wrap reports more lines
+# than the formula assumed and the size walks down from a start that was fine.
+# Letting it climb back is what puts the fitter within 1-2px of both references
+# (47 vs 46, 38 vs 40) instead of 4-5px under them.
+BUDGET = TARGET_H * H * 1.10
+while size > SIZE_MIN and block_lines(size) * size * LINE_H > BUDGET:
+    size -= 1
+while size < SIZE_MAX and block_lines(size + 1) * (size + 1) * LINE_H <= BUDGET:
+    size += 1
+
+lines = block_lines(size)
+span  = lines * size * LINE_H / H
+print(f"type: {size}px x{LINE_H} -> {lines} lines, block span {span*100:.1f}% of frame")
+
+if size <= SIZE_MIN:
+    print("WARNING: the fitter clamped at the minimum. The wall is too long — cut words.")
+if span > 0.40:
+    print(f"WARNING: block span {span*100:.1f}% > 40%. It will crowd the platform's own UI. Cut words.")
+
+# ------------------------------------------------------------- 3. cut the scene
+outdir.mkdir(parents=True, exist_ok=True)
+media = outdir / "media"; media.mkdir(exist_ok=True)
+
+# scale+crop to fill 1080x1920. NEVER letterbox and never blur-bar.
+# (A line starting with "#" that also contains the three letters D-N-A gets
+#  indexed as a strand heading by `vidfarm harness show`, even inside a fenced
+#  code block. Hence the missing cross-reference here — it is deliberate.)
+# setpts/asetpts rebase to zero: after -ss the first frame carries a PTS a hair
+# above 0, and a nonzero start makes frame 0 render as nothing — which in this
+# format is the thumbnail.
+vf = (f"scale={W}:{H}:force_original_aspect_ratio=increase,"
+      f"crop={W}:{H},fps={FPS},setpts=PTS-STARTPTS")
+
+# PING-PONG: cut HALF the duration, then play it forward and reversed.
+#
+# The loop seam is a real cut that never appears in your editor and that every
+# viewer sees at least once — and `duration = words/8` made it worse, because a
+# longer clip means the plate drifted further between its first and last frame.
+# Measured on an 8.9s aerial plate: the straight cut's seam is 18.0 mean absolute
+# frame delta against a median frame-to-frame step of 3.4 — the loop join is a 5x
+# jump. Ping-ponged, the same plate measures 0.4, SMALLER than one ordinary frame
+# step, because the last frame IS the first frame.
+#
+# trim=start_frame=1 drops the duplicated middle frame; without it the turnaround
+# holds for two frames and reads as a hitch.
+#
+# Turn it off (--no-pingpong) when the plate has a clear DIRECTIONAL subject: a
+# person walking reverses into a moonwalk and it is the only thing anyone sees.
+# It is invisible on ambient drift, aerials, water, rain and distant traffic,
+# which is what this format casts anyway.
+PINGPONG = "--no-pingpong" not in sys.argv and "--keep-scene-audio" not in sys.argv
+cut_dur = DUR / 2 if PINGPONG else DUR
+
+# THE SCENE IS MUTED (-an). Its own audio is a liability you did not choose — wind,
+# a voice, a siren, someone else's music. Every one of those is an audio EVENT, and
+# an event pulls a reader off the line they are on. Pass --keep-scene-audio only
+# after MEASURING it (LRA <= 3.0, no speech) on footage you own.
+# --keep-scene-audio forces --no-pingpong above: reversed audio is unmistakable
+# even where reversed picture is not.
+audio_args = ["-af", "asetpts=PTS-STARTPTS,loudnorm=I=-21:LRA=3:TP=-1.5",
+              "-c:a", "aac", "-b:a", "128k"] if "--keep-scene-audio" in sys.argv else ["-an"]
+subprocess.run(["ffmpeg", "-v", "error", "-y", "-ss", str(TIN), "-t", str(cut_dur), "-i", scene,
+                "-vf", vf, *audio_args,
+                "-c:v", "libx264", "-crf", "20", "-pix_fmt", "yuv420p",
+                "-movflags", "+faststart", str(media / "scene.mp4")], check=True)
+
+if PINGPONG:
+    subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(media / "scene.mp4"),
+                    "-filter_complex",
+                    "[0:v]split[a][b];[b]reverse,trim=start_frame=1,setpts=PTS-STARTPTS[r];"
+                    "[a][r]concat=n=2:v=1[v]",
+                    "-map", "[v]", "-c:v", "libx264", "-crf", "20", "-pix_fmt", "yuv420p",
+                    "-movflags", "+faststart", str(media / "scene-pp.mp4")], check=True)
+    shutil.move(str(media / "scene-pp.mp4"), str(media / "scene.mp4"))
+    print(f"ping-pong: {cut_dur:.2f}s forward + reversed -> {DUR:.2f}s, seamless loop")
+
+# The bed. Synthesised if none is given — free, flat, and congruent with any night
+# exterior. Measured on the references the bed is essentially a constant (LRA 2.1
+# and 0.7), so LRA=1 here is the right side to err on.
+if "--keep-scene-audio" not in sys.argv:
+    bed = BED or str(media / "bed.m4a")
+    if not BED:
+        subprocess.run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi",
+                        "-i", f"anoisesrc=c=pink:r=44100:a=0.9:d={DUR + 1}",
+                        "-af", "lowpass=f=520,highpass=f=45,loudnorm=I=-21:LRA=1:TP=-2.0",
+                        "-ac", "2", "-c:a", "aac", "-b:a", "128k", bed], check=True)
+    subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(media / "scene.mp4"), "-i", bed,
+                    "-map", "0:v", "-map", "1:a", "-shortest", "-c:v", "copy",
+                    "-c:a", "aac", "-b:a", "128k", "-movflags", "+faststart",
+                    str(media / "scene-bed.mp4")], check=True)
+    shutil.move(str(media / "scene-bed.mp4"), str(media / "scene.mp4"))
+
+# ------------------------------------------------------- 4. the frame-0 poster
+# -vframes 1 with no -ss, so this is genuinely frame 0. Sampling with fps=N
+# would hand back the middle of the first interval instead.
+subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(media / "scene.mp4"),
+                "-vframes", "1", str(media / "poster.png")], check=True)
+
+# the font must be self-hosted with NO fallback chain — a missing font would
+# silently render as a different one and nothing would report it
+font_src = pathlib.Path("assets/fonts/TikTokSans-700.woff2")
+fonts = media / "fonts"; fonts.mkdir(exist_ok=True)
+if font_src.exists():
+    shutil.copy(font_src, fonts / "TikTokSans-700.woff2")
+else:
+    print(f"WARNING: {font_src} not found. Put the self-hosted .woff2 there before rendering.")
+
+# --------------------------------------------------------------- 5. index.html
+body = "\n".join(
+    f'<p>{html.escape(p)}</p>' if i == 0 else f'<p class="tail">{html.escape(p)}</p>'
+    for i, p in enumerate(paras))
+
+handle_html = (f'<div class="handle">{html.escape(HANDLE)}</div>' if HANDLE else "")
+left_pct = (0.5 + OFFSET) * 100
+
+HTML = f"""<!doctype html>
+<html lang="en"><head><meta charset="UTF-8">
+<meta name="viewport" content="width={W}, height={H}">
+<title>wall-text — {outdir.name}</title>
+<style>
+ /* Self-hosted, NO fallback chain. A fallback means a missing font renders as a
+    DIFFERENT font and nothing tells you — the video just quietly stops looking
+    like it came out of the platform's own text tool. */
+ @font-face{{font-family:'TikTok Sans';font-style:normal;font-weight:700;font-display:block;
+   src:url('media/fonts/TikTokSans-700.woff2') format('woff2')}}
+ body{{margin:0;background:#000}}
+ #root{{position:relative;width:{W}px;height:{H}px;overflow:hidden;background:#000}}
+ .clip{{position:absolute;inset:0}}
+
+ /* THE WALL.
+    - NO plate, no background, no gradient. Legibility is bought by casting a dark
+      scene (median luma <= 60) plus this shadow. A plate is the single clearest
+      "made in an editor" tell and it is unfixable in the edit.
+    - The shadow is insurance for the SPECULAR case: measured p98 luma behind the
+      block in both references is ~176, i.e. streetlights genuinely do sweep across
+      the text for a few frames over a few percent of its area.
+    - text-align:center with a fixed box width, and NO hand-broken lines. Breaks
+      landing mid-clause are what a dragged text box does; clause-aligned breaks
+      read as typeset, and typeset reads as an ad.
+    - The block is vertically CENTRED (both references: 50.0% and 49.9%), and the
+      centred horizontally (both references measure 49.9% and 50.0% per line). */
+ .wall{{
+   position:absolute;
+   left:{left_pct:.2f}%;
+   top:50%;
+   transform:translate(-50%,-50%);
+   width:{box_w}px;
+   font-family:'TikTok Sans';
+   font-weight:700;
+   font-size:{size}px;
+   line-height:{LINE_H};
+   color:#FFFFFF;
+   text-align:center;
+   letter-spacing:0;
+   text-shadow:0 2px 10px rgba(0,0,0,.60), 0 0 3px rgba(0,0,0,.50);
+ }}
+ .wall p{{margin:0}}
+ /* the ONE permitted manual break: the poster's own closing line, one blank line down */
+ .wall p.tail{{margin-top:{int(size*LINE_H)}px}}
+
+ /* THE HANDLE. Attribution, not a CTA — findable on a screenshot, not readable at
+    a glance. Same no-plate rule as the wall. Omitted entirely in TURN mode. */
+ .handle{{
+   position:absolute;left:0;right:0;
+   top:calc(50% + {int(lines*size*LINE_H/2) + 40}px);
+   font-family:'TikTok Sans';font-weight:700;font-size:26px;
+   color:rgba(255,255,255,.55);letter-spacing:.02em;text-align:center;
+   text-shadow:0 2px 8px rgba(0,0,0,.6);
+ }}
+</style></head><body>
+<div id="root" data-composition-id="{outdir.name}" data-start="0"
+     data-width="{W}" data-height="{H}" data-duration="{DUR}">
+
+  <!-- POSTER. Frame 0 renders before the <video> has decoded anything, so without
+       this still the thumbnail ships as an empty background — and in this format
+       frame 0 IS the video (Rule 5). -->
+  <img id="poster" class="clip" data-start="0" data-duration="{DUR}" data-end="{DUR}"
+       data-track-index="0" data-layer-kind="image" data-layer-mode="publish"
+       data-hf-id="poster" data-label="frame-0 poster"
+       src="media/poster.png" style="width:100%;height:100%;object-fit:cover">
+
+  <!-- ONE unbroken take, MUTED (data-volume 0). The bed is laid separately: a background
+       clip's own audio is a liability you did not choose — wind, a voice, a siren, someone
+       else's music — and every one of those is an audio EVENT that pulls a reader off the
+       line they are on. No cuts exist in this format. -->
+  <video id="scene" class="clip" data-start="0" data-duration="{DUR}" data-end="{DUR}"
+         data-track-index="1" data-layer-kind="video" data-layer-mode="publish"
+         data-hf-id="scene" data-label="ambient POV/UGC scene"
+         data-volume="0" data-playback-start="0"
+         src="media/scene.mp4" playsinline preload="auto"
+         style="width:100%;height:100%;object-fit:cover"></video>
+
+  <!-- THE WALL. data-start="0" and data-duration = the full composition: it is
+       complete at frame 0 and unchanged at the last frame. There is no other
+       timing in this format, and nothing here animates (Rule 3). -->
+  <div id="wall" class="wall" data-start="0" data-duration="{DUR}" data-end="{DUR}"
+       data-track-index="2" data-layer-kind="text" data-layer-mode="publish"
+       data-hf-id="wall" data-label="the wall">
+{body}
+  </div>
+  {handle_html}
+
+</div></body></html>
+"""
+
+(outdir / "index.html").write_text(HTML, encoding="utf-8")
+print(f"\nwrote {outdir}/index.html")
+print(f"next:  python3 band-measure.py {media/'scene.mp4'} --top {0.5-span/2:.3f} --bot {0.5+span/2:.3f}")
+print(f"then:  vidfarm qa {outdir} --harness ./experimental/wall-text-pov-ugc.md")
+```
+
+---
+
+## Appendix B — `band-measure.py` (gate 1: cast it, before you build)
+
+The cheapest gate in the file by an order of magnitude. Run it on a candidate clip and recast
+in thirty seconds instead of after a render.
+
+```python
+#!/usr/bin/env python3
+"""
+Measure the background behind the wall, across the WHOLE clip, and say whether
+plate-free type survives it.
+
+usage: band-measure.py <clip.mp4> [--top 0.33] [--bot 0.67] [--l 0.16] [--r 0.84] [--fps 10]
+
+Why the thresholds are what they are — measured across all 51 sampled frames of
+both reference templates, inside the block's own rect:
+
+                                    ref A   ref B    gate
+  median luma, worst frame            18      17     <= 60
+  mean luma, worst frame              38      39     <= 90
+  % of band pixels > 120, worst        8.5%    8.6%  <= 15%
+  p98 luma (specular hits)           175     176     no gate
+  frame-to-frame motion                3.6     3.8   1.5 .. 20
+
+THE STANDARD DEVIATION LIES HERE, and that is the whole point of this script.
+Both references measure a band std of 43-47, which the general HARNESS.md
+treatment table reads as "busy -> needs a plate". It is wrong. The variation is
+a handful of streetlights a few pixels across; 40px+ type with a soft shadow
+sails straight over them. So this gates on the MEDIAN and on the FRACTION of
+bright pixels, never on the std — and it reports the std anyway so nobody
+re-derives this the hard way.
+
+Text pixels are excluded (>190) so this works on a finished render as well as on
+a bare clip.
+"""
+import subprocess, sys, numpy as np
+
+clip = sys.argv[1]
+def opt(f, d): return float(sys.argv[sys.argv.index(f)+1]) if f in sys.argv else d
+TOP, BOT = opt("--top", 0.33), opt("--bot", 0.67)
+L,   R   = opt("--l", 0.16),   opt("--r", 0.84)
+FPS      = opt("--fps", 10)
+
+SW, SH = 270, 480
+p = subprocess.run(["ffmpeg", "-v", "error", "-i", clip,
+                    "-vf", f"fps={FPS},scale={SW}:{SH}", "-f", "rawvideo",
+                    "-pix_fmt", "gray", "-"], capture_output=True).stdout
+n = len(p) // (SW * SH)
+if n == 0:
+    sys.exit("no frames decoded — is that a video?")
+a = np.frombuffer(p, np.uint8)[:n*SW*SH].reshape(n, SH, SW).astype(float)
+
+band = a[:, int(TOP*SH):int(BOT*SH), int(L*SW):int(R*SW)]
+bg   = np.where(band > 190, np.nan, band)          # drop the type's own pixels
+
+med    = np.array([np.nanmedian(f)            for f in bg])
+mean   = np.array([np.nanmean(f)              for f in bg])
+std    = np.array([np.nanstd(f)               for f in bg])
+bright = np.array([np.nanmean(f > 120)        for f in bg])
+p98    = np.array([np.nanpercentile(f, 98)    for f in bg])
+
+print(f"{clip}  {n} frames sampled at {FPS}fps, band {TOP:.2f}-{BOT:.2f} x {L:.2f}-{R:.2f}")
+print(f"  median luma   mean {med.mean():6.1f}   worst frame {med.max():6.1f}   gate <= 60")
+print(f"  mean luma     mean {mean.mean():6.1f}   worst frame {mean.max():6.1f}   gate <= 90")
+print(f"  %pixels >120  mean {bright.mean()*100:5.1f}%   worst frame {bright.max()*100:5.1f}%   gate <= 15%")
+print(f"  p98 (specular) max {p98.max():6.0f}   (no gate — this is what the shadow is for)")
+print(f"  std           mean {std.mean():6.1f}   NOT a gate — see the docstring")
+
+fail = []
+if med.max()    > 60:   fail.append(f"median luma {med.max():.0f} > 60 — too bright for plate-free type")
+if mean.max()   > 90:   fail.append(f"mean luma {mean.max():.0f} > 90")
+if bright.max() > 0.15: fail.append(f"{bright.max()*100:.0f}% of the band is over 120 — the scene is competing")
+
+# a scene that never changes is a still, and a still has no loop seam to hide behind
+motion = np.abs(np.diff(a[:, ::4, ::4], axis=0)).mean()
+print(f"  motion        {motion:6.1f}   (references: 3.6 and 3.8. < 1.5 is a freeze, > 20 is competing)")
+if motion < 1.5: fail.append(f"motion {motion:.1f} — this clip is effectively a still image")
+if motion > 20:  fail.append(f"motion {motion:.1f} — too much is happening. The scene will steal the reading")
+
+if fail:
+    print("\nFAIL")
+    for f in fail: print("  x", f)
+    print("\n  fix: recast, or grade uniformly and re-measure:")
+    print("    ffmpeg -i in.mp4 -vf eq=brightness=-0.10:contrast=1.05:saturation=0.90 -c:a copy out.mp4")
+    print("  do NOT fix it with a plate, a gradient behind the text, or a blur (Rule 4).")
+    sys.exit(1)
+print("\nPASS — plate-free type survives this scene.")
+```
+
+---
+
+## Appendix C — `walltext-qa.py` (gate 3: enforce it on the RENDER)
+
+Front-matter `checks:` grade the composition and `vidfarm qa` grades the DOM. Neither can see
+the finished MP4, and this format's two signature failures — a loop ratio under 2.5, and a
+frame 0 that shipped empty — are only visible there.
+
+```python
+#!/usr/bin/env python3
+"""
+Grade a rendered wall-text video.
+
+usage: walltext-qa.py <out.mp4> --wall <wall.txt> [--mode mirror|turn] [--offer "dishcover.io"]
+
+Checks, in order:
+  1. duration and canvas
+  2. frame 0 and the LAST frame are both live AND both carry the wall
+     (it loops — there is no tail, and the last frame is a thumbnail too)
+  3. the block's geometry: vertical centre, span, horizontal offset
+  4. the loop ratio and the word floor
+  5. the band, across every sampled frame (the same gate as Appendix B)
+  6. NO PLATE — detected by looking for a rectangle of uniform luma behind the text
+  7. audio: present, flat, normalised, and not speech
+  8. motion continuity: one unbroken take, no cut inside the clip
+  9. the wall, as written: forbidden phrases, statistics, and the offer's placement
+
+The pole/mode changes what is allowed (Rule 7). Default to MIRROR — it is the
+stricter of the two, so an unset mode can never silently pass a resolution that
+nobody decided to allow.
+"""
+import subprocess, sys, re, json, pathlib, numpy as np
+
+vid = sys.argv[1]
+def opt(f, d, c=str): return c(sys.argv[sys.argv.index(f)+1]) if f in sys.argv else d
+WALL  = opt("--wall", None)
+MODE  = opt("--mode", "mirror").lower()
+OFFER = opt("--offer", "").lower()
+
+W, H = 1080, 1920
+fails, warns = [], []
+def bad(m):  fails.append(m)
+def warn(m): warns.append(m)
+
+# ------------------------------------------------------------- 1. container
+pr = json.loads(subprocess.run(
+    ["ffprobe", "-v", "error", "-show_format", "-show_streams", "-of", "json", vid],
+    capture_output=True, text=True).stdout)
+v = next((s for s in pr["streams"] if s["codec_type"] == "video"), None)
+au = next((s for s in pr["streams"] if s["codec_type"] == "audio"), None)
+dur = float(pr["format"]["duration"])
+if not v: sys.exit("no video stream")
+if (v["width"], v["height"]) != (W, H): bad(f"canvas {v['width']}x{v['height']}, expected {W}x{H}")
+if not 7.9 <= dur <= 12.1:
+    bad(f"duration {dur:.2f}s outside 8-12s — the 8s floor is what lets a poster lay a "
+        f"trending sound over this and get a real phrase of a track")
+if not au: bad("NO AUDIO — a silent upload is down-ranked and reads as broken")
+
+# ------------------------------------- 2. frame 0 and the last frame, both live
+# -vframes 1 with an explicit -ss, never fps=N: `fps` hands back the middle of
+# the first interval, so a genuinely blank frame 0 would sample as a fine still.
+def grab(t):
+    p = subprocess.run(["ffmpeg", "-v", "error", "-ss", f"{t}", "-i", vid, "-vframes", "1",
+                        "-f", "rawvideo", "-pix_fmt", "gray", "-"], capture_output=True).stdout
+    if len(p) < W*H: return None
+    return np.frombuffer(p[:W*H], np.uint8).reshape(H, W).astype(float)
+
+f0, fl = grab(0.0), grab(max(0.0, dur - 0.06))
+for label, fr in (("frame 0", f0), ("last frame", fl)):
+    if fr is None:
+        bad(f"{label} did not decode"); continue
+    if fr.mean() < 2.0:
+        bad(f"{label} is black — no poster still, or the tail runs past the clip")
+    txt = (fr > 200).sum()
+    if txt < 4000:
+        bad(f"{label} carries {txt}px of type — the wall is not up (Rule 5). "
+            f"Frame 0 needs an explicit poster; the last frame needs data-duration to match.")
+
+# ------------------------------------------------------ 3. the block geometry
+if f0 is not None:
+    m = f0 > 210
+    dens = m.sum(1)                       # lit columns per row
+    lit  = dens > 40
+
+    # Group lit rows into RUNS, keep runs >= 8 rows tall, then keep only runs
+    # whose PEAK density is >= 40% of the strongest run's.
+    #
+    # Taking rows.min()/rows.max() straight off the mask is the obvious version
+    # and it is wrong on exactly the footage this format casts. A streetlight
+    # flare is a lit run 90+ rows tall, nowhere near the text. On reference A it
+    # reads the block as 7%-65% (centre 36.1%, span 58.1%) instead of the real
+    # 35.0%-65.1% — three failed checks, every one of them a phantom.
+    #
+    # Height alone does not separate them (the flare is TALLER than a text line).
+    # Density does, by a wide margin: on reference A the text lines peak at
+    # 176-388 lit columns and the flare peaks at 60. The %-of-strongest rule is
+    # scale-free, so it survives a different font size and a brighter flare —
+    # a hardcoded column threshold would not.
+    #
+    # 25%, not 40%. The closing ask is a STRUCTURAL feature of this format and it
+    # is deliberately short — "is this true?" is three words against a 12-word
+    # body line, so it lights ~37% of the peak columns and a 40% cut silently
+    # drops it. The block then measures short and off-centre (25.8% span, 47.7%
+    # centre) and the video fails a geometry check it actually passes. The flare
+    # sits at 15%, so 25% still separates them cleanly.
+    runs, s = [], None
+    for i, val in enumerate(lit):
+        if val and s is None: s = i
+        if not val and s is not None:
+            runs.append((s, i)); s = None
+    if s is not None: runs.append((s, len(lit)))
+    runs = [r for r in runs if r[1] - r[0] >= 8]
+    if runs:
+        peak = max(dens[a:b].max() for a, b in runs)
+        runs = [r for r in runs if dens[r[0]:r[1]].max() >= 0.25 * peak]
+
+    if len(runs) < 3:
+        bad(f"could not find a text block in frame 0 ({len(runs)} text-like rows runs)")
+    else:
+        r0, r1 = runs[0][0], runs[-1][1]
+        top, bot = r0/H, r1/H
+        centre, span = (top+bot)/2, bot-top
+        # Horizontal centre: take the MEDIAN of each text line's own centre,
+        # not the union extent of all of them. A light sitting inside the block's
+        # rows drags a union extent hard (on reference B it moves the reported
+        # reported centre from the true 50.0% to 43.9%),
+        # but it can only corrupt the one line it overlaps, and the median
+        # outvotes it. Lines are ragged either side, so their centres agree.
+        centres = []
+        for a, b in runs:
+            c = np.where(m[a:b].sum(0) > 1)[0]
+            if len(c) > 20:
+                centres.append((c.min()+c.max())/2/W)
+        hcentre = float(np.median(centres)) if centres else 0.5
+        print(f"block: centre {centre*100:.1f}%  span {span*100:.1f}%  hcentre {hcentre*100:.1f}%")
+        if not 0.48 <= centre <= 0.52:
+            bad(f"block vertical centre {centre*100:.1f}% — the spec is 48-52% (both references: 50.0%)")
+        if not 0.28 <= span <= 0.42:
+            warn(f"block span {span*100:.1f}% — the references are 30.3% and 38.3%")
+        if not 0.48 <= hcentre <= 0.52:
+            warn(f"box horizontal centre {hcentre*100:.1f}% — the spec is 48-52%. "
+                 f"Both references measure 49.9% and 50.0%")
+        if top < 0.08 or bot > 0.85:
+            bad(f"block runs {top*100:.0f}%-{bot*100:.0f}%, outside the 8-85% safe zone")
+
+# ---------------------------------------------- 4. the loop ratio and the floor
+wall = ""
+if WALL:
+    wall = pathlib.Path(WALL).read_text(encoding="utf-8").strip()
+    words = len(wall.split())
+    ratio = (words / 4.0) / dur
+    print(f"wall: {words} words -> read {words/4.0:.1f}s / {dur:.2f}s = loop ratio {ratio:.2f}")
+    # No word floor — see Rule 2. Out of band is a note about the CLIP, never the wall.
+    print(f"       {100/ratio:.0f}% of the wall is read per play (target 50%, band 42-56%)")
+    if ratio > 2.4:
+        warn(f"ratio {ratio:.2f} — only {100/ratio:.0f}% read per play. The clip is too short; "
+             f"words/8 = {words/8.0:.1f}s. Never fix this by adding words")
+    elif ratio < 1.8 and words >= 64:
+        warn(f"ratio {ratio:.2f} — {100/ratio:.0f}% read per play, near enough to finish in one "
+             f"pass, so the loop stops working. Cut the clip to {words/8.0:.1f}s")
+    elif ratio < 1.8:
+        kind = "partial loop" if ratio >= 1.3 else "SINGLE-READ, no loop"
+        print(f"       {words} words vs the 8s music floor -> {kind} (ratio {ratio:.2f}). "
+              f"A trade, not a defect — intended, if you chose it.")
+else:
+    warn("no --wall given; skipped the loop ratio, which is the format's central check")
+
+# ---------------------------------------------------- 5. the band, every frame
+p = subprocess.run(["ffmpeg", "-v", "error", "-i", vid, "-vf", "fps=10,scale=270:480",
+                    "-f", "rawvideo", "-pix_fmt", "gray", "-"], capture_output=True).stdout
+n = len(p)//(270*480)
+a = np.frombuffer(p, np.uint8)[:n*270*480].reshape(n, 480, 270).astype(float)
+band = a[:, int(.30*480):int(.70*480), int(.16*270):int(.84*270)]
+bg   = np.where(band > 190, np.nan, band)
+med    = max(np.nanmedian(f) for f in bg)
+bright = max(np.nanmean(f > 120) for f in bg)
+print(f"band: worst median {med:.0f} (gate 60)  worst %>120 {bright*100:.1f}% (gate 15%)")
+if med    > 60:   bad(f"band median luma {med:.0f} > 60 — too bright for plate-free type (Rule 4)")
+if bright > 0.15: bad(f"{bright*100:.0f}% of the band is over 120 — the scene is competing with the wall")
+
+# --------------------------------------------------------------- 6. NO PLATE
+# A plate is a rectangle of near-uniform luma sitting behind the type. Real
+# footage inside the block's rect is never uniform for long. So: take the band's
+# background pixels and ask how much of the frame's area sits in one narrow luma
+# bin. Footage spreads; a plate spikes.
+plate_hits = 0
+for f in bg[::3]:
+    x = f[~np.isnan(f)]
+    if len(x) < 500: continue
+    hist, _ = np.histogram(x, bins=32, range=(0, 255))
+    if hist.max() / len(x) > 0.72 and np.nanstd(x) < 9:
+        plate_hits += 1
+if plate_hits > len(bg[::3]) * 0.5:
+    bad("a PLATE is detected behind the wall — uniform luma across the block's rect. "
+        "There is no plate in this format at any opacity (Rule 4)")
+
+# --------------------------------------------------------------- 7. the audio
+if au:
+    out = subprocess.run(["ffmpeg", "-hide_banner", "-i", vid, "-af", "ebur128=peak=true",
+                          "-f", "null", "-"], capture_output=True, text=True).stderr
+    # findall()[-1], NOT search(). ebur128 streams a per-frame "I:" line for the
+    # whole clip and only THEN prints the summary, so search() returns frame 0's
+    # integrated loudness — which is -70 LUFS on every file ever made, and fails
+    # every video for an audio defect none of them have.
+    Is   = re.findall(r"I:\s*(-?[\d.]+)\s*LUFS", out)
+    LRAs = re.findall(r"LRA:\s*([\d.]+)\s*LU", out)
+    if Is and LRAs:
+        I, LRA = float(Is[-1]), float(LRAs[-1])
+        print(f"audio: {I:.1f} LUFS, LRA {LRA:.1f} LU")
+        if not -23.5 <= I <= -17.5:
+            bad(f"{I:.1f} LUFS outside -23..-18. Run loudnorm=I=-21:LRA=3:TP=-1.5")
+        if LRA > 3.0:
+            bad(f"LRA {LRA:.1f} LU > 3.0 — the bed has structure. It must be flat: "
+                f"any audio event pulls a reader off the line they are on (references: 2.1 and 0.7)")
+
+# ------------------------------------------ 8. one take, no cut inside the clip
+d = np.abs(np.diff(a[:, ::4, ::4].reshape(n, -1), axis=0)).mean(1)
+if len(d) > 3:
+    spike = d.max() / max(1e-6, np.median(d))
+    print(f"motion: median {np.median(d):.1f}, worst jump x{spike:.1f} the median")
+    if spike > 6:
+        bad(f"a CUT is detected inside the clip (frame delta {spike:.1f}x the median). "
+            f"This format is one unbroken take")
+    if np.median(d) < 1.0:
+        bad("the background is effectively frozen — a still with text on it, not a scene")
+
+# ------------------------------------------------- 9. the wall, as written
+if wall:
+    low = wall.lower()
+    BANNED = ["link in bio", "sign up", "free trial", "get started", "book a demo",
+              "download now", "learn more", "swipe up", "dm me", "comment below",
+              "follow for", "part two", "part 2"]
+    for b in BANNED:
+        if b in low: bad(f'the wall contains "{b}" — the bait is the post caption, never the video (Rule 9)')
+    if re.search(r"\b\d+\s?%|\b\d+x\b|\$\s?\d", low):
+        bad("a statistic or a money figure is in the wall — a confession does not cite data (Rule 8)")
+    if OFFER:
+        named = OFFER in low
+        if MODE == "mirror" and named:
+            bad(f'MIRROR mode names "{OFFER}" in the wall. In MIRROR the offer lives in the '
+                f'handle and the post caption only (Rule 7)')
+        if MODE == "turn" and not named:
+            bad(f'TURN mode does not name "{OFFER}" anywhere in the wall — then it is a MIRROR post')
+        if MODE == "turn" and low.count(OFFER) > 1:
+            bad(f'TURN mode names "{OFFER}" {low.count(OFFER)} times. Once, in the pivot, then stop')
+
+# ------------------------------------------------------------------- verdict
+print()
+for w_ in warns: print("  ! ", w_)
+if fails:
+    print("FAIL")
+    for f in fails: print("  x ", f)
+    sys.exit(1)
+print("PASS")
+```
+
+---
+
+## Appendix D — a worked example
+
+The build log for one MIRROR post. This is the whole artifact — three lines of thinking, one
+wall, one clip.
+
+```
+WHO:      solo founder, ships alone, no team
+MOMENT:   1am, third night in a row, the launch post still unwritten
+THE ACHE: I am not blocked. I just cannot bear to be perceived getting it wrong.
+
+MODE:     MIRROR
+FRAME:    📻 overheard
+SCENE:    POV — night drive, empty arterial road, streetlights
+RIGHTS:   owned (shot on a dashboard mount, 2026-08-14)
+```
+
+The wall (`wall.txt`):
+
+```
+a founder told me “the reason you haven’t posted in four months isn’t
+that you’re busy. it’s that posting means someone can watch you be
+mediocre in public, and you’ve built an entire company specifically so
+that nobody ever gets to. every system you added, every process, every
+‘let me just polish this first’ — that was the same instinct wearing a
+work shirt. you didn’t build a business, you built a place to hide.”
+
+is he right?
+```
+
+The numbers, as the tools actually report them:
+
+| | Value | Gate |
+|---|---|---|
+| Words | 78 | ≥ 40 ✅ |
+| Chars | 432 | |
+| Read time | 19.5s | |
+| Clip | 8.0s (`words/8`, floored) | 8–12s ✅ |
+| **Loop ratio** | **2.44** | 1.8–2.4 ✅ |
+| Fitted size | 38px | ≥ 30 ✅ |
+| Lines | 15 | |
+| Block span | 37.1% | ≤ 40% ✅ |
+| Band median luma, worst frame | 16 | ≤ 60 ✅ |
+| Band % > 120, worst frame | 7.3% | ≤ 15% ✅ |
+| Motion | 3.6 | 1.5–20 ✅ |
+
+The build:
+
+```bash
+python3 band-measure.py raws/nightdrive-arterial.mp4 --top .32 --bot .68   # gate 1 — cast it
+python3 walltext-build.py raws/nightdrive-arterial.mp4 wall.txt work/v001 \
+        --dur 5.6 --in 142 --case lower
+vidfarm qa work/v001 --harness ./experimental/wall-text-pov-ugc.md          # gate 2 — the DOM
+vidfarm render work/v001 --local --out work/v001/out.mp4
+python3 walltext-qa.py work/v001/out.mp4 --wall wall.txt --mode mirror \
+        --offer "dishcover.io"                                              # gate 3 — the render
+```
+
+The post caption — where the offer and the second copy of the ask live:
+
+```
+he said this to me in a car park and I haven't recovered. is he right, or is that
+just something people say to founders who are genuinely busy?
+
+(I'm the one who hid. dishcover.io shipped 11 months late for exactly this reason.)
+```
+
+**Note what the caption does that the wall is not allowed to do:** it names the offer, it
+concedes something unflattering and true, and it repeats the ask. All three would break the
+wall. The post caption is not an afterthought in this format — it is the second half of the
+build, and it carries everything the video deliberately cannot.
+
+---
+
+## Appendix E — `walltext-batch.py` (one background, N walls)
+
+The format's whole economic argument, in one script.
+
+```python
+#!/usr/bin/env python3
+"""
+Build N compositions from ONE background and a TSV of walls.
+
+usage: walltext-batch.py <scene.mp4> <walls.tsv> <outroot> [--in 142] [--handle "…"]
+
+walls.tsv — one row per video, tab-separated:
+    <slug>\t<dur>\t<mode>\t<path/to/wall.txt>
+
+Holding the background CONSTANT across the batch is deliberate, not lazy (see
+"Bulk generation"): it is free to hold, it is the variable that matters least,
+and it is what makes the comparison between walls mean anything. A batch where
+the wall and the background both changed teaches you nothing.
+
+It also builds the account's recognisability — both reference templates are the
+same creator, the same road, the same treatment, five days apart.
+"""
+import subprocess, sys, pathlib, csv
+
+scene, tsv, root = sys.argv[1], sys.argv[2], pathlib.Path(sys.argv[3])
+passthru = sys.argv[4:]
+here = pathlib.Path(__file__).parent
+
+rows = [r for r in csv.reader(open(tsv), delimiter="\t") if r and not r[0].startswith("#")]
+print(f"{len(rows)} walls -> {root}/\n")
+
+ok, failed = [], []
+for slug, dur, mode, wallpath in rows:
+    out = root / slug
+    print(f"── {slug}  ({mode}, {dur}s)")
+    r = subprocess.run([sys.executable, str(here/"walltext-build.py"),
+                        scene, wallpath, str(out), "--dur", dur] + passthru)
+    (failed if r.returncode else ok).append(slug)
+    print()
+
+print(f"built {len(ok)}  failed {len(failed)}")
+if failed:
+    print("failed:", ", ".join(failed))
+    print("almost always the loop ratio or the 40-word floor — both are in the build output above.")
+```
+
+---
+
+## What this format is NOT
+
+Worth stating, because each of these is one small step away and each is a different harness:
+
+| If you find yourself… | You are building | Use |
+|---|---|---|
+| …cutting between two clips | a short-form edit | `HARNESS.md` (round 1) |
+| …adding a voiceover and captions | a UGC testimonial or an explainer | `ugc-reaction-greenscreen` |
+| …hand-breaking the lines and plating the text | a meme caption | `meme-recaption` |
+| …putting the product on screen | a product demo | `product-demo` |
+| …animating the text in | a motion graphic | `/motion-graphics` |
+
+**The discipline of this format is entirely subtractive.** Everything you know how to do makes
+it worse. The only two things you get to be good at are the wall and the casting, and the wall
+is 95% of it.